--
Within an instance constructor of a struct type, the "this" keyword behaves exactly as an output parameter of the struct type
--
A user-defined conversion is NOT allowed to which of the following types? 
Choice 1   
 "struct" and "array" types  
Choice 2   
 "abstract class" and "object" types  
Choice 3   
 "object" and "interface" types  
Choice 4   
 "struct" and "enum" types  
Choice 5   
 "delegate" and "enum" types

--
internal class Piston {} 

internal class Engine 
{ 
 private Piston[] myPistons = new Piston[4]; 
 public bool Ignition() { 
   // some code... 
   return true; 
 } 
} 

public class Car 
{ 
 private Engine myEngine = new Engine(); 
 public void Start() 
 { 
   // put in keys etc... 
   if (myEngine.Ignition()) { 
     // some more code 
   } 
 } 
}  
  What OO concept does the above sample code demonstrate?  
Choice 1   
 Combination  
Choice 2   
 Inheritance  
Choice 3   
 Composition  
Choice 4   
 Polymorphism  
Choice 5   
 Delegation  
--
Which one of the following describes the OO concept of Aggregation?  
Choice 1   
 A system of objects that define each other  
Choice 2   
 A system of objects that are not related  
Choice 3   
 A system of objects that implement each other  
Choice 4   
 A system of objects inherited from each other  
Choice 5   
 A system of objects that are built using each other

--
Which one of the following variable types is NOT classified as initially assigned?  
Choice 1   
 Value parameters  
Choice 2   
 Instance variables of class instances  
Choice 3   
 Local variables  
Choice 4   
 Static variables  
Choice 5   
 Array elements  
--

dub>--
dub>--
dub>A user-defined conversion is NOT allowed to which of the following types? 

dub>

dub>--
dub>internal class Piston {} 

dub>internal class Engine 
dub>{ 
dub> private Piston[] myPistons = new Piston[4]; 
dub> public bool Ignition() { 
dub>   // some code... 
dub>   return true; 
dub> } 
dub>} 

dub>public class Car 
dub>{ 
dub> private Engine myEngine = new Engine(); 
dub> public void Start() 
dub> { 
dub>   // put in keys etc... 
dub>   if (myEngine.Ignition()) { 
dub>     // some more code 
dub>   } 
dub> } 
dub>}

dub>--
dub>Which one of the following describes the OO concept of Aggregation?  
dub>Choice 1   
dub> A system of objects that define each other  
dub>Choice 2   
dub> A system of objects that are not related  
dub>Choice 3   
dub> A system of objects that implement each other  
dub>Choice 4   
dub> A system of objects inherited from each other  
dub>Choice 5   
dub> A system of objects that are built using each other

dub>--
dub>Which one of the following variable types is NOT classified as initially assigned?  
dub>Choice 1   
dub> Value parameters  
dub>Choice 2   
dub> Instance variables of class instances  
dub>Choice 3   
dub> Local variables  
dub>Choice 4   
dub> Static variables  
dub>Choice 5   
dub> Array elements  
dub>--

dub>>--
dub>>Within an instance constructor of a struct type, the "this" keyword behaves exactly as an output parameter of the struct type
dub>>--
СТ>А в чем вопрос? :-)

dub>>A user-defined conversion is NOT allowed to which of the following types? 
dub>>Choice 1   
dub>> "struct" and "array" types  
dub>>Choice 2   
dub>> "abstract class" and "object" types  
dub>>Choice 3   
dub>> "object" and "interface" types  
dub>>Choice 4   
dub>> "struct" and "enum" types  
dub>>Choice 5   
dub>> "delegate" and "enum" types  
dub>>

Error 1 'OneDemPoint.implicit operator object(OneDemPoint)': user-defined conversion to/from base class ...\OTHER\udc\Program.cs 26 23 udc

Error 1 'OneDemPoint.implicit operator IFooInterface(OneDemPoint)': user-defined conversion to/from interface ...\OTHER\udc\Program.cs 26 23

dub>>>--
dub>>>Within an instance constructor of a struct type, the "this" keyword behaves exactly as an output parameter of the struct type
dub>>>--

СТ>>А в чем вопрос?

    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        struct MyStruct
        {
            int Age;
            string Name;
            
            public MyStruct(int age)
            {
                this = new MyStruct(age, "Anonymous");    
            }
            
            public MyStruct(int age, string name)
            {
                Age = age;
                Name = name;
            }
            
            public override string ToString()
            {
                return string.Format("Age: {0}\t\tName: {1}", Age.ToString(), Name);
            }
            
        }
        
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            MyStruct ms = new MyStruct(42);
            Console.WriteLine(ms.ToString());
            Console.Read();
        }
    }

User-Defined Conversions

Whatever we explained till now is the conversions (implicit or explicit) among the basic data types or among same user defined data types. Suppose we have to do conversions between basic data types and user defined data types or between two incompatible user-efined data types. C# provides a facility to define conversion operators inside a class or struct to achieve this.

But C# provides only certain user-defined conversions to be defined. In particular it is not possible to redefine an existing implicit or explicit conversion in C#. A class or struct is permitted to declare a conversion function from a source type S to a target type T only if all of the following are true.

1. Both S & T are different types.
2. Either S or T is a class or struct type in which the operator declaration takes place.
3. Neither S nor T is an object type or an interface type.
4. T is not a base class of S or S is not a base class of T.

The user-defined conversion can either implicit or explicit. The general form of user-defined conversion operator is as follows.

pblic static implicit/explicit operator type (arguments)

{

}

Where the operator is the required keyword and type is the required return type. Remember that operator function should be public and static and there is no return type. The presence of the keyword explicit makes the conversion as explicit and implicit keyword makes the conversion as implicit.

The conversion operator can be defined either inside the class or struct type. Remember that user defined conversions are not allowed to convert from or to interface types. Also note that since explicit or implicit keywords are not part of the method’s signature, it is not possible to declare both explicit and implicit conversion operator with a same source and target type.

An example for a user-defined conversion is shown below.

class A
{
    class Nested!
    {}
    class Nested2
    {}

}