Software Technologies

This is an agile HTML parser that builds a read/write DOM and supports plain XPATH or XSLT (you actually don't HAVE to understand XPATH nor XSLT to use it, don't worry...). It is a .NET code library that allows you to parse "out of the web" HTML files. The parser is very tolerant with "real world" malformed HTML. The object model is very similar to what proposes System.Xml, but for HTML documents (or streams). 

There is no dependency on anything else than .Net's XPATH implementation. There is no dependency on Internet Explorer's MSHTML dll or W3C's HTML tidy or ActiveX / COM object, or anything like that. There is also no adherence to XHTML or XML, although you can actually produce XML using the tool. The version posted here on CodePlex is for the .NET Framework 2.0. If you need the old version, please go to the old page or drop me a note.

https://msdn.microsoft.com/en-us/library/windows/desktop/ms683835%28v=vs.85%29.aspx

A critical aspect of COM is how clients and servers interact. A COM client is whatever code or object gets a pointer to a COM server and uses its services by calling the methods of its interfaces. A COM server is any object that provides services to clients; these services are in the form of COM interface implementations that can be called by any client that is able to get a pointer to one of the interfaces on the server object.

There are two main types of servers, in-process and out-of-process. In-process servers are implemented in a dynamic linked library (DLL), and out-of-process servers are implemented in an executable file (EXE). Out-of-process servers can reside either on the local computer or on a remote computer. In addition, COM provides a mechanism that allows an in-process server (a DLL) to run in a surrogate EXE process to gain the advantage of being able to run the process on a remote computer. For more information, see DLL Surrogates.

The COM programming model and constructs have now been extended so that COM clients and servers can work together across the network, not just within a given computer. This enables existing applications to interact with new applications and with each other across networks with proper administration, and new applications can be written to take advantage of networking features.

COM client applications do not need to be aware of how server objects are packaged, whether they are packaged as in-process objects (in DLLs) or as local or remote objects (in EXEs). Distributed COM further allows objects to be packaged as service applications, synchronizing COM with the rich administrative and system-integration capabilities of Windows.

COM is designed to make it possible to add the support for location transparency that extends across a network. It allows applications written for single computers to run across a network and provides features that extend these capabilities and add to the security necessary in a network. (For more information, see Security in COM.)

COM specifies a mechanism by which the class code can be used by many different applications.

For more information, see the following topics:

Type casting is one of the unavoidable things in software development. In many situations we need to convert one object (Type) to another object (Type) and some times we get an exception like this: "Cannot implicitly convert type 'Object one' to 'object two'". To avoid this type of exceptions and check object compatibility, C# provides two operators namely is and as.

The is operator in C# is used to check the object type and it returns a bool value: true if the object is the same type and false if not.

For null objects, it returns false.

Syntax:

namespace IsAndAsOperators
{
    // Sample Student Class
    class Student
    {
        public int stuNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }

    }
    // Sample Employee Class
    class Employee
    {
        public int EmpNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public double Salary { get; set; }

    }
    class Program
    {

        static void Main(string[] args)
        {
            Student stuObj = new Student();
            stuObj.stuNo = 1;
            stuObj.Name = "Siva";
            stuObj.Age = 15;

            Employee EMPobj=new Employee();
            EMPobj.EmpNo=20;
            EMPobj.Name="Rajesh";
            EMPobj.Salary=100000;
            EMPobj.Age=25;

            // Is operator

            // Check Employee EMPobj is Student Type

            bool isStudent = (EMPobj is Student);
            System.Console.WriteLine("Empobj is a Student ?: {0}", isStudent.ToString());

            // Check Student stiObj is Student Typoe
            isStudent = (stuObj is Student);
            System.Console.WriteLine("Stuobj is a Student ?: {0}", isStudent.ToString());

            stuObj = null;
            // Check  null object Type
            isStudent = (stuObj is Student);
            System.Console.WriteLine("Stuobj(null) is a Student ?: {0}", isStudent.ToString());
            System.Console.ReadLine();
        }
    }

Output

Empobj is a Student ?: False
Stuobj is a Student ?: True 
Stuobj(null) is a Student ?: False

as operator

Type obj = Object as Type;

namespace IsAndAsOperators
{
    // Sample Student Class
    class Student
    {
        public int stuNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }

    }
    // Sample Employee Class
    class Employee
    {
        public int EmpNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public double Salary { get; set; }

    }
    class Program
    {
        static void Main(string[] args)
        {
            Student stuObj = new Student();
            stuObj.stuNo = 1;
            stuObj.Name = "Praveen";
            stuObj.Age = 15;

            Employee EMPobj=new Employee();
            EMPobj.EmpNo=20;
            EMPobj.Name="Rajesh";
            EMPobj.Salary=100000;
            EMPobj.Age=25;     

            System.Console.WriteLine("Empobj is a Student ?: {0}", CheckAndConvertobject(EMPobj));

            System.Console.WriteLine("StuObj is a Student ?: {0}", CheckAndConvertobject(stuObj));
            System.Console.ReadLine();

        }

        public static string CheckAndConvertobject(dynamic obj)
        {
           // If obj is Type student it asign value to Stuobj else it asign null
            Student stuobj = obj as Student;
            if (stuobj != null)
                return "This is a Student and his name is " + stuobj.Name;

                return "Not a Student";         


        }
    }   
}

Output:

Empobj is a Student ?: Not a Student 
StuObj is a Student ?: This is a Student and his name is Praveen

Advantage of 'as' over 'is

1. Check the Type using is
2. If it’s true then Type cast