c# ocr github

aspose ocr c# example

ocr class c#

c# ocr freeware

c# ocr tesseract,

ocr sdk c#,
best ocr api c#,

c# windows ocr,
ocr c# github,
c# ocr pdf,
c# microsoft.windows.ocr,
best ocr api for c#,
best free ocr library c#,
emgu cv ocr c# example,
google ocr api c#,
c# pdf ocr,
c# zonal ocr,
onenote ocr in c#,
ocr class c#,
windows.media.ocr example c#,
c# aspose ocr example,
c# .net ocr library free,
onenote ocr in c#,
ocr c# github,

best ocr sdk c#,
c# .net ocr library free,
ocr library c# free,
zonal ocr c#,
leadtools ocr c# example,
abbyy ocr c#,
ocr sdk c#,
c# pdf ocr library,
c# tesseract ocr download,
abbyy ocr c#,
tesseract ocr pdf c#,
how to use tesseract ocr with c#,
c# free ocr api,
ocr api c#,
tesseract ocr c# code project,
c# tesseract ocr tiff,
c# ocr open source,
how to implement ocr in c#,
c# winforms ocr,
emgu ocr c# example,
ocr in c#,
ocr sdk c#,
tesseract ocr c# nuget,
best free ocr library c#,
ironocr c# example,
best ocr api for c#,
tesseract ocr pdf to text c#,
ocr library c#,
onenote ocr c# example,
emgu cv ocr c# example,
c# free ocr api,
tesseract ocr c# image to text,
abbyy ocr c#,
adobe sdk ocr c#,
c# tesseract ocr tiff,
c# tesseract ocr pdf example,
ocr in c#,
microsoft ocr c# example,
c# aspose ocr example,
ocr api c#,
c# tesseract ocr pdf example,
convert image to text ocr free c#,
microsoft ocr library c#,
ocr class c#,
c# ocr free,
open source ocr library c#,
best ocr api for c#,
convert image to text ocr free c#,
c# ocr example,

Figure 15-8. GUI for MyExtendableApp The code that handles the Click event for the File Snap In Module menu item (which may be created simply by double-clicking the menu item from the design-time editor) displays a File Open dialog box and extracts the path to the selected file. Assuming the user did not select the CommonSnappableTypes.dll assembly (as this is purely infrastructure), the path is then sent into a helper function named LoadExternalModule() for processing (implemented next). This method will return false when it is unable to find a class implementing IAppFunctionality: private void snapInModuleToolStripMenuItem_Click(object sender, EventArgs e) { // Allow user to select an assembly to load. OpenFileDialog dlg = new OpenFileDialog(); if (dlg.ShowDialog() == DialogResult.OK) { if(dlg.FileName.Contains("CommonSnappableTypes")) MessageBox.Show("CommonSnappableTypes has no snap-ins!"); else if(!LoadExternalModule(dlg.FileName)) MessageBox.Show("Nothing implements IAppFunctionality!"); } } The LoadExternalModule() method performs the following tasks: Dynamically loads the selected assembly into memory Determines whether the assembly contains any types implementing IAppFunctionality Creates the type using late binding

fid serial,

If a type implementing IAppFunctionality is found, the DoIt() method is called, and the fully qualified name of the type is added to the ListBox (note that the foreach loop will iterate over all types in the assembly to account for the possibility that a single assembly has multiple snap-ins). private bool LoadExternalModule(string path)

{ bool foundSnapIn = false; Assembly theSnapInAsm = null; try { // Dynamically load the selected assembly. theSnapInAsm = Assembly.LoadFrom(path); } catch(Exception ex) { MessageBox.Show(ex.Message); return foundSnapIn; } // Get all IAppFunctionality compatible classes in assembly. var theClassTypes = from t in theSnapInAsm.GetTypes() where t.IsClass && (t.GetInterface("IAppFunctionality") != null) select t; // Now, create the object and call DoIt() method. foreach (Type t in theClassTypes) { foundSnapIn = true; // Use late binding to create the type. IAppFunctionality itfApp = (IAppFunctionality)theSnapInAsm.CreateInstance(t.FullName, true); itfApp.DoIt(); lstLoadedSnapIns.Items.Add(t.FullName); } return foundSnapIn; } At this point, you can run your application. When you select the CSharpSnapIn.dll or VbSnapIn.dll assemblies, you should see the correct message displayed. The final task is to display the metadata provided by the [CompanyInfo] attribute. To do so, update LoadExternalModule() to call a new helper function named DisplayCompanyData() before exiting the foreach scope. Notice this method takes a single System.Type parameter. private bool LoadExternalModule(string path) { ... foreach (Type t in theClassTypes) { ... // Show company info. DisplayCompanyData(t); } return foundSnapIn; } Using the incoming type, simply reflect over the [CompanyInfo] attribute:

Primary key: unique flood event ID Name of event (e.g., contact) Identifier of the visitor, such as an IP address or hostname

private void DisplayCompanyData(Type t) { // Get [CompanyInfo] data. var compInfo = from ci in t.GetCustomAttributes(false) where (ci.GetType() == typeof(CompanyInfoAttribute)) select ci; // Show data. foreach (CompanyInfoAttribute c in compInfo) { MessageBox.Show(c.CompanyUrl, string.Format("More info about {0} can be found at", c.CompanyName)); } } Figure 15-9 shows one possible run.

Figure 15-9. Snapping in external assemblies Excellent! That wraps up the example application. I hope you can see that the topics presented in this chapter can be quite helpful in the real world and are not limited to the tool builders of the world.

The forum table stores the relationship of nodes to forum terms. Table A-50. forum (forum module)

Source Code The ExtendableApp folder under the 15 subdirectory contains the CommonSnappableTypes, CSharpSnapIn, VbSnapIn, and MyExtendableApp projects.

Summary

Reflection is a very interesting aspect of a robust OO environment. In the world of .NET, the keys to reflection services revolve around the System.Type class and the System.Reflection namespace. As you have seen, reflection is the process of placing a type under the magnifying glass at runtime to understand the who, what, where, when, why, and how of a given item. Late binding is the process of creating a type and invoking its members without prior knowledge of the specific names of said members. Late binding is often a direct result of dynamic loading, which allows you to load a .NET assembly into memory programmatically. As shown during this chapter s extendable application example, this is a very powerful technique used by tool builders as well as tool consumers. This chapter also examined the role of attribute-based programming. When you adorn your types with attributes, the result is the augmentation of the underlying assembly metadata.

0 0 0