public static bool operator ==(XamlMember xamlMember1, XamlMember xamlMember2) { if (ReferenceEquals(xamlMember1, xamlMember2)) { return(true); } if (xamlMember1 is null || xamlMember2 is null) { return(false); } if (xamlMember1._memberType != xamlMember2._memberType || xamlMember1.Name != xamlMember2.Name) { return(false); } if (xamlMember1.IsDirective) { Debug.Assert(xamlMember2.IsDirective); // DeclaringType is null for directives, so we need to compare namespaces. // Known and unknown directives are equal if the names and namespaces match return(XamlDirective.NamespacesAreEqual((XamlDirective)xamlMember1, (XamlDirective)xamlMember2)); } else { // Known and unknown members are not equal, even if they otherwise match return(xamlMember1.DeclaringType == xamlMember2.DeclaringType && xamlMember1.IsUnknown == xamlMember2.IsUnknown); } }
private static XamlDirective GetXmlDirective(string name) { XamlDirective result = new XamlDirective(s_xmlNamespaces, name, String, BuiltInValueConverter.String, AllowedMemberLocations.Attribute); return(result); }
private static XamlDirective GetXamlDirective(string name, XamlType xamlType, XamlValueConverter <TypeConverter> typeConverter, AllowedMemberLocations allowedLocation) { XamlDirective result = new XamlDirective(s_xamlNamespaces, name, xamlType, typeConverter, allowedLocation); return(result); }
private static ReadOnlyCollection <XamlDirective> GetAllDirectives() { XamlDirective[] result = new XamlDirective[] { Arguments, AsyncRecords, Class, Code, ClassModifier, ConnectionId, FactoryMethod, FieldModifier, Key, Initialization, Items, Members, ClassAttributes, Name, PositionalParameters, Shared, Subclass, SynchronousMode, TypeArguments, Uid, UnknownContent, Base, Lang, Space }; return(new ReadOnlyCollection <XamlDirective>(result)); }
public virtual XamlDirective GetXamlDirective(string xamlNamespace, string name) { XamlDirective t; var p = new Pair(xamlNamespace, name); if (!xaml_directives.TryGetValue(p, out t)) { t = new XamlDirective(xamlNamespace, name); xaml_directives.Add(p, t); } return(t); }
internal static bool NamespacesAreEqual(XamlDirective directive1, XamlDirective directive2) { IList <string> list = directive1._xamlNamespaces; IList <string> list2 = directive2._xamlNamespaces; if (list.Count != list2.Count) { return(false); } for (int i = 0; i < list.Count; i++) { if (list[i] != list2[i]) { return(false); } } return(true); }
// We use the private field _xamlNamespaces to avoid expensive lookups or mutable // return values from overriden implementations of GetXamlNamespaces. But this will produce // hard-to-understand behavior if the namespaces returned from GetXamlNamespaces are different // from the ones passed in the ctor. Ideally we would provide overridable equality here. internal static bool NamespacesAreEqual(XamlDirective directive1, XamlDirective directive2) { IList <string> ns1 = directive1._xamlNamespaces; IList <string> ns2 = directive2._xamlNamespaces; if (ns1.Count != ns2.Count) { return(false); } for (int i = 0; i < ns1.Count; i++) { if (ns1[i] != ns2[i]) { return(false); } } return(true); }
public static bool operator ==(XamlMember xamlMember1, XamlMember xamlMember2) { if (object.ReferenceEquals(xamlMember1, xamlMember2)) { return(true); } if (object.ReferenceEquals(xamlMember1, null) || object.ReferenceEquals(xamlMember2, null)) { return(false); } if ((xamlMember1._memberType != xamlMember2._memberType) || (xamlMember1.Name != xamlMember2.Name)) { return(false); } if (xamlMember1.IsDirective) { return(XamlDirective.NamespacesAreEqual((XamlDirective)xamlMember1, (XamlDirective)xamlMember2)); } return((xamlMember1.DeclaringType == xamlMember2.DeclaringType) && (xamlMember1.IsUnknown == xamlMember2.IsUnknown)); }
// lookups protected virtual XamlMember LookupAliasedProperty(XamlDirective directive) { if (directive == XamlLanguage.Key) { var a = this.GetCustomAttribute <DictionaryKeyPropertyAttribute> (); return(a != null?GetMember(a.Name) : null); } if (directive == XamlLanguage.Name) { var a = this.GetCustomAttribute <RuntimeNamePropertyAttribute> (); return(a != null?GetMember(a.Name) : null); } if (directive == XamlLanguage.Uid) { var a = this.GetCustomAttribute <UidPropertyAttribute> (); return(a != null?GetMember(a.Name) : null); } if (directive == XamlLanguage.Lang) { var a = this.GetCustomAttribute <XmlLangPropertyAttribute> (); return(a != null?GetMember(a.Name) : null); } return(null); }
// returns remaining attributes to be processed Dictionary <string, string> ProcessAttributes(List <Pair> members) { var l = members; // base string xmlbase = r.GetAttribute("base", XamlLanguage.Xml1998Namespace) ?? r.BaseURI; if (types.Count == 0 && xmlbase != null) // top { l.Add(new Pair(XamlLanguage.Base, xmlbase)); } var atts = new Dictionary <string, string> (); if (r.MoveToFirstAttribute()) { do { switch (r.NamespaceURI) { case XamlLanguage.Xml1998Namespace: switch (r.LocalName) { case "base": continue; // already processed. case "lang": l.Add(new Pair(XamlLanguage.Lang, r.Value)); continue; case "space": l.Add(new Pair(XamlLanguage.Space, r.Value)); continue; } break; case XamlLanguage.Xmlns2000Namespace: continue; case XamlLanguage.Xaml2006Namespace: XamlDirective d = FindStandardDirective(r.LocalName, AllowedMemberLocations.Attribute); if (d != null) { l.Add(new Pair(d, r.Value)); continue; } throw new NotSupportedException(String.Format("Attribute '{0}' is not supported", r.Name)); default: if (r.NamespaceURI == String.Empty) { atts.Add(r.Name, r.Value); continue; } // Should we just ignore unknown attribute in XAML namespace or any other namespaces ? // Probably yes for compatibility with future version. break; } } while (r.MoveToNextAttribute()); r.MoveToElement(); } return(atts); }
static XamlLanguage() { InitializingTypes = true; // types Array = XT <ArrayExtension> (); Boolean = XT <bool> (); Byte = XT <byte> (); Char = XT <char> (); Decimal = XT <decimal> (); Double = XT <double> (); Int16 = XT <short> (); Int32 = XT <int> (); Int64 = XT <long> (); Member = XT <MemberDefinition> (); Null = XT <NullExtension> (); Object = XT <object> (); Property = XT <PropertyDefinition> (); Reference = XT <Reference> (); Single = XT <float> (); Static = XT <StaticExtension> (); String = XT <string> (); TimeSpan = XT <TimeSpan> (); Type = XT <TypeExtension> (); Uri = XT <Uri> (); XData = XT <XData> (); InitializingTypes = false; AllTypes = new ReadOnlyCollection <XamlType> (new XamlType [] { Array, Boolean, Byte, Char, Decimal, Double, Int16, Int32, Int64, Member, Null, Object, Property, Reference, Single, Static, String, TimeSpan, Type, Uri, XData }); // directives var nss = new string [] { XamlLanguage.Xaml2006Namespace }; var nssXml = new string [] { XamlLanguage.Xml1998Namespace }; Arguments = new XamlDirective(nss, "Arguments", XT <List <object> > (), null, AllowedMemberLocations.Any); AsyncRecords = new XamlDirective(nss, "AsyncRecords", XT <string> (), null, AllowedMemberLocations.Attribute); Base = new XamlDirective(nssXml, "base", XT <string> (), null, AllowedMemberLocations.Attribute); Class = new XamlDirective(nss, "Class", XT <string> (), null, AllowedMemberLocations.Attribute); ClassAttributes = new XamlDirective(nss, "ClassAttributes", XT <List <Attribute> > (), null, AllowedMemberLocations.MemberElement); ClassModifier = new XamlDirective(nss, "ClassModifier", XT <string> (), null, AllowedMemberLocations.Attribute); Code = new XamlDirective(nss, "Code", XT <string> (), null, AllowedMemberLocations.Attribute); ConnectionId = new XamlDirective(nss, "ConnectionId", XT <string> (), null, AllowedMemberLocations.Any); FactoryMethod = new XamlDirective(nss, "FactoryMethod", XT <string> (), null, AllowedMemberLocations.Any); FieldModifier = new XamlDirective(nss, "FieldModifier", XT <string> (), null, AllowedMemberLocations.Attribute); Initialization = new XamlDirective(nss, "_Initialization", XT <object> (), null, AllowedMemberLocations.Any); Items = new XamlDirective(nss, "_Items", XT <List <object> > (), null, AllowedMemberLocations.Any); Key = new XamlDirective(nss, "Key", XT <object> (), null, AllowedMemberLocations.Any); Lang = new XamlDirective(nssXml, "lang", XT <string> (), null, AllowedMemberLocations.Attribute); Members = new XamlDirective(nss, "Members", XT <List <MemberDefinition> > (), null, AllowedMemberLocations.MemberElement); Name = new XamlDirective(nss, "Name", XT <string> (), null, AllowedMemberLocations.Attribute); PositionalParameters = new XamlDirective(nss, "_PositionalParameters", XT <List <object> > (), null, AllowedMemberLocations.Any); Space = new XamlDirective(nssXml, "space", XT <string> (), null, AllowedMemberLocations.Attribute); Subclass = new XamlDirective(nss, "Subclass", XT <string> (), null, AllowedMemberLocations.Attribute); SynchronousMode = new XamlDirective(nss, "SynchronousMode", XT <string> (), null, AllowedMemberLocations.Attribute); Shared = new XamlDirective(nss, "Shared", XT <string> (), null, AllowedMemberLocations.Attribute); TypeArguments = new XamlDirective(nss, "TypeArguments", XT <string> (), null, AllowedMemberLocations.Attribute); Uid = new XamlDirective(nss, "Uid", XT <string> (), null, AllowedMemberLocations.Attribute); UnknownContent = new XamlDirective(nss, "_UnknownContent", XT <object> (), null, AllowedMemberLocations.MemberElement) { InternalIsUnknown = true }; AllDirectives = new ReadOnlyCollection <XamlDirective> (new XamlDirective [] { Arguments, AsyncRecords, Base, Class, ClassAttributes, ClassModifier, Code, ConnectionId, FactoryMethod, FieldModifier, Initialization, Items, Key, Lang, Members, Name, PositionalParameters, Space, Subclass, SynchronousMode, Shared, TypeArguments, Uid, UnknownContent }); SpecialNames = new SpecialTypeNameList(); }
public XamlMember GetAliasedProperty(XamlDirective directive) { return(LookupAliasedProperty(directive)); }
public void DefaultValuesWithComplexParams () { var d = new XamlDirective (new string [0], "Foo", new XamlType (typeof (object), sctx), null, AllowedMemberLocations.Any); Assert.AreEqual (AllowedMemberLocations.Any, d.AllowedLocation, "#1"); Assert.IsNull (d.DeclaringType, "#2"); Assert.IsNotNull (d.Invoker, "#3"); Assert.IsNull (d.Invoker.UnderlyingGetter, "#3-2"); Assert.IsNull (d.Invoker.UnderlyingSetter, "#3-3"); Assert.IsFalse (d.IsUnknown, "#4"); // different from another test Assert.IsTrue (d.IsReadPublic, "#5"); Assert.IsTrue (d.IsWritePublic, "#6"); Assert.AreEqual ("Foo", d.Name, "#7"); Assert.IsTrue (d.IsNameValid, "#8"); Assert.AreEqual (null, d.PreferredXamlNamespace, "#9"); // different from another test (as we specified empty array above) Assert.IsNull (d.TargetType, "#10"); Assert.IsNotNull (d.Type, "#11"); Assert.AreEqual (typeof (object), d.Type.UnderlyingType, "#11-2"); Assert.IsNull (d.TypeConverter, "#12"); Assert.IsNull (d.ValueSerializer, "#13"); Assert.IsNull (d.DeferringLoader, "#14"); Assert.IsNull (d.UnderlyingMember, "#15"); Assert.IsFalse (d.IsReadOnly, "#16"); Assert.IsFalse (d.IsWriteOnly, "#17"); Assert.IsFalse (d.IsAttachable, "#18"); Assert.IsFalse (d.IsEvent, "#19"); Assert.IsTrue (d.IsDirective, "#20"); Assert.IsNotNull (d.DependsOn, "#21"); Assert.AreEqual (0, d.DependsOn.Count, "#21-2"); Assert.IsFalse (d.IsAmbient, "#22"); Assert.AreEqual (DesignerSerializationVisibility.Visible, d.SerializationVisibility, "#23"); }
protected override XamlMember LookupAliasedProperty(XamlDirective directive) { if (directive == XamlLanguage.Name) { return CallGetMember(_runtimeNamePropertyName); } else if (directive == XamlLanguage.Key && _dictionaryKeyPropertyName != null) { return LookupMember(_dictionaryKeyPropertyName, true); } else if (directive == XamlLanguage.Lang) { return CallGetMember(_xmlLangPropertyName); } else if (directive == XamlLanguage.Uid) { return CallGetMember(_uidPropertyName); } else { return null; } }
public XamlMember GetNoDotAttributeProperty(XamlType tagType, XamlPropertyName propName, string tagNamespace, string propUsageNamespace, bool tagIsRoot) { XamlMember xamlAttachableProperty = null; if ((propUsageNamespace == tagNamespace) || (((tagNamespace == null) && (propUsageNamespace != null)) && tagType.GetXamlNamespaces().Contains(propUsageNamespace))) { XamlType rootObjectType = tagIsRoot ? tagType : null; xamlAttachableProperty = this.GetXamlProperty(tagType, propName.Name, rootObjectType); if (xamlAttachableProperty == null) { xamlAttachableProperty = this.GetXamlAttachableProperty(tagType, propName.Name); } } if ((xamlAttachableProperty == null) && (propUsageNamespace != null)) { XamlDirective xamlDirective = this.SchemaContext.GetXamlDirective(propUsageNamespace, propName.Name); if (xamlDirective != null) { if ((xamlDirective.AllowedLocation & AllowedMemberLocations.Attribute) == AllowedMemberLocations.None) { xamlDirective = new XamlDirective(propUsageNamespace, propName.Name); } xamlAttachableProperty = xamlDirective; } } if (xamlAttachableProperty != null) { return xamlAttachableProperty; } if (tagNamespace == propUsageNamespace) { return new XamlMember(propName.Name, tagType, false); } return new XamlDirective(propUsageNamespace, propName.Name); }
public void DefaultValuesWithName () { var d = new XamlDirective ("urn:foo", "Foo"); Assert.AreEqual (AllowedMemberLocations.Any, d.AllowedLocation, "#1"); Assert.IsNull (d.DeclaringType, "#2"); Assert.IsNotNull (d.Invoker, "#3"); Assert.IsNull (d.Invoker.UnderlyingGetter, "#3-2"); Assert.IsNull (d.Invoker.UnderlyingSetter, "#3-3"); Assert.IsTrue (d.IsUnknown, "#4"); Assert.IsTrue (d.IsReadPublic, "#5"); Assert.IsTrue (d.IsWritePublic, "#6"); Assert.AreEqual ("Foo", d.Name, "#7"); Assert.IsTrue (d.IsNameValid, "#8"); Assert.AreEqual ("urn:foo", d.PreferredXamlNamespace, "#9"); Assert.IsNull (d.TargetType, "#10"); Assert.IsNotNull (d.Type, "#11"); Assert.AreEqual (typeof (object), d.Type.UnderlyingType, "#11-2"); Assert.IsNull (d.TypeConverter, "#12"); Assert.IsNull (d.ValueSerializer, "#13"); Assert.IsNull (d.DeferringLoader, "#14"); Assert.IsNull (d.UnderlyingMember, "#15"); Assert.IsFalse (d.IsReadOnly, "#16"); Assert.IsFalse (d.IsWriteOnly, "#17"); Assert.IsFalse (d.IsAttachable, "#18"); Assert.IsFalse (d.IsEvent, "#19"); Assert.IsTrue (d.IsDirective, "#20"); Assert.IsNotNull (d.DependsOn, "#21"); Assert.AreEqual (0, d.DependsOn.Count, "#21-2"); Assert.IsFalse (d.IsAmbient, "#22"); Assert.AreEqual (DesignerSerializationVisibility.Visible, d.SerializationVisibility, "#23"); }
void TestXamlDirectiveCommon (XamlDirective d, string name, string ns, AllowedMemberLocations allowedLocation, Type type) { TestXamlDirectiveCommon (d, name, ns, allowedLocation, type, false); }
public DirectiveMemberInvoker (XamlDirective directive) : base (directive) { }
private static XamlDirective GetXamlDirective(string name, AllowedMemberLocations allowedLocation, MemberReflector reflector) { XamlDirective result = new XamlDirective(s_xamlNamespaces, name, allowedLocation, reflector); return(result); }
public void ConstructorNameNull () { // wow, it is allowed. var d = new XamlDirective (String.Empty, null); Assert.IsNull (d.Name, "#1"); }
public void ConstructorComplexParamsEmptyNamespaces () { var d = new XamlDirective (new string [0], "Foo", new XamlType (typeof (object), sctx), null, AllowedMemberLocations.Any); }
public override void WriteStartObject(XamlType type) { if (type.UnderlyingType == typeof(string)) { isWritingElementStyleString = true; } // this is the top-level object if (this.currentDepth == 0) { if (!this.debugSymbolNamespaceAdded) { string sadsNamespaceAlias = GenerateNamespaceAlias(NameSpaces.DebugSymbolPrefix); this.WriteNamespace(new NamespaceDeclaration(NameSpaces.DebugSymbol, sadsNamespaceAlias)); this.debugSymbolNamespaceAdded = true; } // we need to write MC namespace if any namespaces need to be ignored if (this.namespacesToIgnore.Count > 0) { string mcNamespaceAlias = GenerateNamespaceAlias(NameSpaces.McPrefix); this.WriteNamespace(new NamespaceDeclaration(NameSpaces.Mc, mcNamespaceAlias)); } if (this.localNamespacesWithAssemblyInfo != null) { foreach (NamespaceDeclaration xamlNamespace in this.localNamespacesWithAssemblyInfo) { if ((this.emittedNamespacesInLocalAssembly == null) || (!this.emittedNamespacesInLocalAssembly.Contains(xamlNamespace.Namespace))) { base.WriteNamespace(xamlNamespace); } } } if ((type.UnderlyingType == typeof(Activity)) || (type.IsGeneric && type.UnderlyingType != null && type.UnderlyingType.GetGenericTypeDefinition() == typeof(Activity<>)) || (type.UnderlyingType == typeof(WorkflowService))) { // Exist ActivityBuilder, DebugSymbolObject will be inserted at the depth == 1. debugSymbolDepth = 1; } else { debugSymbolDepth = 0; } } if (this.currentDepth == debugSymbolDepth) { if (type.UnderlyingType != null && type.UnderlyingType.IsSubclassOf(typeof(Activity)) && this.shouldWriteDebugSymbol) { this.writeDebugSymbol = true; } } base.WriteStartObject(type); if (this.currentDepth == 0) { // we need to add Ignore attribute for all namespaces which we don't want to load assemblies for // this has to be done after WriteStartObject if (this.namespacesToIgnore.Count > 0) { string nsString = null; foreach (string ns in this.namespacesToIgnore) { if (nsString == null) { nsString = ns; } else { nsString += " " + ns; } } XamlDirective ignorable = new XamlDirective(NameSpaces.Mc, "Ignorable"); base.WriteStartMember(ignorable); base.WriteValue(nsString); base.WriteEndMember(); this.namespacesToIgnore.Clear(); } } ++this.currentDepth; }
public DirectiveMemberInvoker(XamlDirective directive) : base(directive) { }
public DirectiveAdapter(XamlDirective xamlMember) : base(xamlMember.GetXamlNamespaces(), xamlMember.Name, xamlMember.Type, xamlMember.TypeConverter, xamlMember.AllowedLocation) { }
public void ConstructorComplexParams () { var d = new XamlDirective (new string [] {"urn:foo"}, "Foo", new XamlType (typeof (object), sctx), null, AllowedMemberLocations.Any); }
void TestXamlDirectiveCommon (XamlDirective d, string name, AllowedMemberLocations allowedLocation, Type type) { TestXamlDirectiveCommon (d, name, XamlLanguage.Xaml2006Namespace, allowedLocation, type); }
// returns remaining attributes to be processed List <AttributeInfo> ProcessAttributes(XmlReader r, List <MemberInfo> members, out string typeArgNames) { // base (top element) if (!xmlbase_done) { xmlbase_done = true; string xmlbase = r.GetAttribute("base", XamlLanguage.Xml1998Namespace) ?? r.BaseURI; if (xmlbase != null) { members.Add(new MemberInfo(XamlLanguage.Base, xmlbase, line_info)); } } typeArgNames = null; var atts = new List <AttributeInfo>(); var tagNamespace = r.NamespaceURI; if (r.MoveToFirstAttribute()) { do { switch (r.NamespaceURI) { case XamlLanguage.Xml1998Namespace: switch (r.LocalName) { case "base": continue; // already processed. case "lang": members.Add(new MemberInfo(XamlLanguage.Lang, r.Value, line_info)); continue; case "space": members.Add(new MemberInfo(XamlLanguage.Space, r.Value, line_info)); continue; } break; case XamlLanguage.Xmlns2000Namespace: continue; case XamlLanguage.Xaml2006Namespace: XamlDirective d = FindStandardDirective(r.LocalName, AllowedMemberLocations.Attribute); if (d != null) { // check TypeArguments to resolve Type, and remove them from the list. They don't appear as a node. if (ReferenceEquals(d, XamlLanguage.TypeArguments)) { typeArgNames = r.Value; continue; } members.Add(new MemberInfo(d, r.Value, line_info)); continue; } throw new NotSupportedException(String.Format("Attribute '{0}' is not supported", r.Name)); default: if (string.IsNullOrEmpty(r.NamespaceURI) || tagNamespace == r.NamespaceURI || r.LocalName.IndexOf('.') > 0) { atts.Add(new AttributeInfo(r.Name, r.Value, line_info)); continue; } // Custom directive members.Add(new MemberInfo(SchemaContext.GetXamlDirective(r.NamespaceURI, r.LocalName), r.Value, line_info)); break; } } while (r.MoveToNextAttribute()); r.MoveToElement(); } return(atts); }
void TestXamlDirectiveCommon (XamlDirective d, string name, string ns, AllowedMemberLocations allowedLocation, Type type, bool isUnknown) { Assert.AreEqual (allowedLocation, d.AllowedLocation, "#1"); Assert.IsNull (d.DeclaringType, "#2"); Assert.IsNotNull (d.Invoker, "#3"); Assert.IsNull (d.Invoker.UnderlyingGetter, "#3-2"); Assert.IsNull (d.Invoker.UnderlyingSetter, "#3-3"); Assert.AreEqual (isUnknown, d.IsUnknown, "#4"); Assert.IsTrue (d.IsReadPublic, "#5"); Assert.IsTrue (d.IsWritePublic, "#6"); Assert.AreEqual (name, d.Name, "#7"); Assert.IsTrue (d.IsNameValid, "#8"); Assert.AreEqual (ns, d.PreferredXamlNamespace, "#9"); Assert.IsNull (d.TargetType, "#10"); Assert.IsNotNull (d.Type, "#11"); Assert.AreEqual (type, d.Type.UnderlyingType, "#11-2"); // .NET returns StringConverter, but it should not premise that key must be string (it is object) if (name == "Key") ;//Assert.IsNull (d.TypeConverter, "#12") else if (type.IsGenericType || name == "_Initialization" || name == "_UnknownContent") Assert.IsNull (d.TypeConverter, "#12"); else Assert.IsNotNull (d.TypeConverter, "#12"); Assert.IsNull (d.ValueSerializer, "#13"); Assert.IsNull (d.DeferringLoader, "#14"); Assert.IsNull (d.UnderlyingMember, "#15"); Assert.IsFalse (d.IsReadOnly, "#16"); Assert.IsFalse (d.IsWriteOnly, "#17"); Assert.IsFalse (d.IsAttachable, "#18"); Assert.IsFalse (d.IsEvent, "#19"); Assert.IsTrue (d.IsDirective, "#20"); Assert.IsNotNull (d.DependsOn, "#21"); Assert.AreEqual (0, d.DependsOn.Count, "#21-2"); Assert.IsFalse (d.IsAmbient, "#22"); Assert.AreEqual (DesignerSerializationVisibility.Visible, d.SerializationVisibility, "#23"); }
internal static bool NamespacesAreEqual(XamlDirective directive1, XamlDirective directive2) { IList<string> list = directive1._xamlNamespaces; IList<string> list2 = directive2._xamlNamespaces; if (list.Count != list2.Count) { return false; } for (int i = 0; i < list.Count; i++) { if (list[i] != list2[i]) { return false; } } return true; }