public List<CompositeType> DoWork()
 {
     comm_sqlDataContext mylinq = new comm_sqlDataContext();
         ISingleResult<adrbook> bb = mylinq.getdata();
         var peoples = new List<CompositeType> ();
         foreach (adrbook cast in bb)
         {
             CompositeType p = new CompositeType();
             p.Lid= cast.id;
             p.Ltype = cast.type;
             p.Lsubtype = cast.subtype;
             p.Llastname = cast.lastname;
             p.Lfirstname = cast.firstname;
             p.Lmiddlename = cast.middlename;
             p.Lpost = cast.post;
             p.Lemail1 = cast.email1;
             p.Lemail2 = cast.email2;
             p.Lroom = cast.room;
             p.Lphone1 = cast.phone1;
             p.Lphone2 = cast.phone2;
             p.Lphone3 = cast.phone3;
             peoples.Add(p);
         }
         return peoples;
 }

		public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
		{
			if (typesToMock == null)
				throw new ArgumentNullException("typesToMock");

			Type primaryType = typesToMock.PrimaryType;
			Type[] additionalInterfaces = BuildAdditionalTypeArrayForProxyType(typesToMock);
			IInterceptor mockInterceptor = new MockObjectInterceptor(mockFactory, typesToMock, name, mockStyle);
			object result;

			/* ^ */ var _typeInfo = primaryType.GetTypeInfo(); /* [email protected] ^ */

			if (/* ^ */ _typeInfo.IsInterface /* [email protected] ^ */)
			{
				result = generator.CreateInterfaceProxyWithoutTarget(primaryType, additionalInterfaces, new ProxyGenerationOptions {BaseTypeForInterfaceProxy = typeof (InterfaceMockBase)}, mockInterceptor);
				((InterfaceMockBase) result).Name = name;
			}
			else
			{
				result = generator.CreateClassProxy(primaryType, additionalInterfaces, ProxyGenerationOptions.Default, constructorArgs, mockInterceptor);
				//return generator.CreateClassProxy(primaryType, new []{typeof(IMockObject)}, mockInterceptor);
			}

			return result;
		}

 public void TestConstructorFailureNullItemNames()
 {
     CompositeType type = new CompositeType("TypeName", "TypeDescription",
     new string[] {"ItemName1", null},
     new string[] {"ItemDescr1", "ItemDescr2"},
     new OpenType[] { SimpleType.Integer, SimpleType.Double});
 }

 protected MockObject(CompositeType mockedType, string name, IExpectationCollector expectationCollector, IInvocationListener invocationListener)
 {
     this.name = name;
     this.invocationListener = invocationListener;
     this.expectationCollector = expectationCollector;
     mockedTypes = mockedType;
 }

 public MethodReference(CompositeType owner, string name, Prototype prototype)
     : this()
 {
     Owner = owner;
     Name = name;
     Prototype = prototype;
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="MockObject"/> class.
		/// </summary>
		/// <param name="mockFactory">The mockFactory.</param>
		/// <param name="mockedType">Type of the mocked.</param>
		/// <param name="name">The name.</param>
		/// <param name="mockStyle">The mock style.</param>
		protected MockObject(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle)
		{
			MockFactory = mockFactory;
			MockStyle = mockStyle;
			MockName = name;
			eventHandlers = new Dictionary<string, List<Delegate>>();
			MockedTypes = mockedType;
		}

 public CompositeType GetDataUsingDataContract(CompositeType composite)
 {
   if (composite.BoolValue)
   {
     composite.StringValue += "Suffix";
   }
   return composite;
 }

 public void DisplayMessage(CompositeType composite)
 {
     string username = composite.Username ?? "";
     string message = composite.Message ?? "";
     // Dispatcher is here to take care of threads ownership over UI components
     Dispatcher.Invoke(() =>
     {
         ChatHistory.Text += (username + ": " + message + Environment.NewLine);
     });
 }

    public CompositeType GetDataUsingDataContract(CompositeType composite)
    {
        Console.WriteLine(String.Format("GetDataUsingDataContract(Composite({0}, {1})", composite.BoolValue, composite.StringValue));

        if (composite.BoolValue)
        {
            composite.StringValue += "Suffix";
        }
        return composite;
    }

 public CompositeType GetDataUsingDataContract(CompositeType composite)
 {
     if (composite == null) {
         throw new ArgumentNullException("composite");
     }
     if (composite.BoolValue) {
         composite.StringValue += "Suffix";
     }
     return composite;
 }

        public void Ws2007HttpBindingTest()
        {
            using (var client = new ServiceClient("Ws2007HttpEndpoint"))
            {
                var input = new CompositeType { BoolValue = true, StringValue = "Hello, world!" };
                var result = client.GetDataUsingDataContract(input);

                Assert.AreEqual<string>(input.StringValue + "Suffix", result.StringValue);
                Assert.AreEqual<bool>(input.BoolValue, result.BoolValue);
            }
        }

        public void LoadFile(string filename)
        {
            XmlDocument document = new XmlDocument();
            document.Load(filename);

            XmlNode compositeNode = document.SelectSingleNode(CompositeXPath);
            string rootNamespace = GetNodeValue(compositeNode, "@rootNamespace");
            RootNamespace = rootNamespace;

            XmlNodeList types = document.SelectNodes(TypesXPath);
            foreach (XmlNode typeNode in types)
            {
                string typeName = GetNodeValue(typeNode, "@name");
                string className = GetNodeValue(typeNode, "@className");
                string theNamespace = GetNodeValue(typeNode, "@namespace");
                if (!Namespaces.Contains(theNamespace))
                {
                    Namespaces.Add(theNamespace);
                }
                CompositeType compositeType = new CompositeType(typeName, className, theNamespace);

                Type foundType = FindType(className, theNamespace);

                foreach (PropertyInfo pi in foundType.GetProperties())
                {
                    if (pi.CanRead && pi.CanWrite)
                    {
                        CompositeProperty property = new CompositeProperty(typeName, pi.Name, pi.PropertyType);
                        compositeType.Properties.Add(property);
                    }
                }

                XmlNodeList hiddenNodes = typeNode.SelectNodes(PropertiesXPath);
                foreach (XmlNode propertyNode in hiddenNodes)
                {
                    string propertyName = GetNodeValue(propertyNode, "@name");
                    string alias = GetNodeValue(propertyNode, "@alias");
                    bool isReadOnly = GetBooleanNodeValue(propertyNode, "@isReadOnly");
                    bool isHidden = GetBooleanNodeValue(propertyNode, "@isHidden");

                    CompositeProperty property = compositeType.Properties.FindCompositeProperty(typeName, propertyName);

                    if (property != null)
                    {
                        if (!String.IsNullOrEmpty(alias))
                        {
                            property.Alias = alias;
                        }
                        property.IsReadOnly = isReadOnly;
                        property.IsHidden = isHidden;
                    }
                }
            }
        }

        public void JavaBytes_To_CompositeType_WithHints()
        {
            // arrange

            // act
            var actual = new CompositeType();
            actual.ComponentTypeHints = _compositeType.Select(t => t.GetType()).ToList();
            actual.SetValueFromBigEndian(_javaByteOrder);

            // assert
            Assert.True(_compositeType.SequenceEqual((CassandraObject[])actual));
        }

        public void JavaBytes_To_CompositeType()
        {
            // arrange
            var expected = new CassandraObject[] { (BytesType)_compositeType[0].GetValue<string>(), (BytesType)_compositeType[1].GetValue<long>() };

            // act
            var actual = new CompositeType();
            actual.SetValueFromBigEndian(_javaByteOrder);

            // assert
            Assert.True(expected.SequenceEqual((CassandraObject[])actual));
        }

 private async void GetCompositeType()
 {
     var serviceClient = new CompositeTypeServiceClient();
     
     var arg = new CompositeType
     {
         StringValue = StringRequest,
     };
     
     var res = await serviceClient.CompositeTypeAsync(arg);
     
     StringResponce = res.StringValue;
 }

        public void Save_CompositeType()
        {
            // arrange
            var family = _db.GetColumnFamily(FamilyName);
            var expected = new CompositeType<LongType, UTF8Type>(300L, "string1");

            // act
            family.InsertColumn(TestKey, expected, Math.PI);
            var value = family.Get(TestKey).Execute();
            var actual = value.FirstOrDefault().Columns.FirstOrDefault();

            // assert
            Assert.AreEqual((object)expected, (object)actual.ColumnName);
        }

     private string CreateGetDataUsingDataContractRequest(CompositeType composite)
     {
         return String.Format(@"<?xml version=""1.0"" encoding=""utf-8""?>
 <s:Envelope xmlns:s=""http://schemas.xmlsoap.org/soap/envelope/"">
     <s:Body>
         <GetDataUsingDataContract xmlns=""http://tempuri.org/"">
             <composite xmlns:d4p1=""http://schemas.datacontract.org/2004/07/AppWithWCF"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">
                 <d4p1:BoolValue>{0}</d4p1:BoolValue>
                 <d4p1:StringValue>{1}</d4p1:StringValue>
              </composite>
         </GetDataUsingDataContract>
     </s:Body>
 </s:Envelope>", composite.BoolValue.ToString().ToLower(), composite.StringValue);
     }

        public void SaveCompositeType()
        {
            CompositeType value = new CompositeType();
            value.Foo = "foobar";
            value.Bar.A = 5;
            value.Bar.B = 10;
            value.Bar.C = "hello \"world\"!";

            Dom dom = Dom.Serialise(value);

            string output = dom.Save();
            string expected = "SaveTest+CompositeType {\n  Foo: String \"foobar\",\n  Bar: SaveTest+NonParsable {\n    A: Int32 \"5\",\n    B: Single \"10\",\n    C: String \"hello \\\"world\\\"!\",\n    D: null\n  }\n}";

            Assert.AreEqual(expected, output);
        }

		public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
		{
			_typesToMock = typesToMock;

			_typesToMock.Add(typeof(IMockObject));

			var reflectiveInterceptor = new ReflectiveInterceptor(mockFactory, typesToMock, name, mockStyle);

			var proxy = CreateMock(reflectiveInterceptor, constructorArgs);

			if (_typesToMock.PrimaryType.IsInterface)
				((InterfaceMockBase) proxy).Name = name;

			return proxy;
		}

 public async Task<CompositeType> GetDataUsingDataContract(CompositeType composite)
 {
     var soapString = this.CreateGetDataUsingDataContractRequest(composite);
     using (var client = new HttpClient())
     {
         client.DefaultRequestHeaders.Add("SOAPAction", "http://tempuri.org/IService1/GetDataUsingDataContract");
         var content = new StringContent(soapString, Encoding.UTF8, "text/xml");
         using (var response = await client.PostAsync(this.uri, content))
         {
             string soapResponse = await response.Content.ReadAsStringAsync();
             CompositeType result = this.ParseGetDataUsingDataContractResponse(soapResponse);
             return result;
         }
     }
 }