public static void TestParse1() { const string x = "a"; MetadataName name = MetadataName.Parse(x); Assert.Equal(x, name.ToString()); }
/// <summary>Snippet for GetMetadata</summary> /// <remarks> /// This snippet has been automatically generated for illustrative purposes only. /// It may require modifications to work in your environment. /// </remarks> public void GetMetadataResourceNames() { // Create client AlphaAnalyticsDataClient alphaAnalyticsDataClient = AlphaAnalyticsDataClient.Create(); // Initialize request argument(s) MetadataName name = MetadataName.FromProperty("[PROPERTY]"); // Make the request Metadata response = alphaAnalyticsDataClient.GetMetadata(name); }
public void Combine_should_qualify_type_with_assembly() { var actual = MetadataName.Combine( AssemblyName.Parse("mscorlib"), TypeName.Parse("String") ); Assert.Equal(SymbolType.Type, actual.SymbolType); Assert.Equal("String, mscorlib", ((TypeName)actual).AssemblyQualifiedName); }
public unsafe void TestIndexOf(string str, char c, int expected) { byte[] bytes = Encoding.UTF8.GetBytes(str + '\0'); fixed(byte *fbytes = &bytes[0]) { MetadataName name = new MetadataName(fbytes, null); Assert.That(name.IndexOf(checked ((byte)c)), Is.EqualTo(expected)); } }
public void Combine_should_qualify_namespace_name_with_other() { var actual = MetadataName.Combine( NamespaceName.Parse("System"), NamespaceName.Parse("IO") ); Assert.Equal(SymbolType.Namespace, actual.SymbolType); Assert.Equal("System.IO", actual.FullName); }
public void Combine_should_combine_nested_type_ns() { var actual = MetadataName.Combine( NamespaceName.Parse("System"), TypeName.Parse("String+Enumerator") ); Assert.Equal(SymbolType.Type, actual.SymbolType); Assert.Equal("System.String+Enumerator", actual.FullName); }
public void Combine_should_qualify_type_with_namespace_name() { var actual = MetadataName.Combine( TypeName.Parse("String"), TypeName.Parse("Enumerator") ); Assert.Equal(SymbolType.Type, actual.SymbolType); Assert.Equal("String+Enumerator", actual.FullName); }
/// <summary>Snippet for GetMetadataAsync</summary> /// <remarks> /// This snippet has been automatically generated for illustrative purposes only. /// It may require modifications to work in your environment. /// </remarks> public async Task GetMetadataResourceNamesAsync() { // Create client BetaAnalyticsDataClient betaAnalyticsDataClient = await BetaAnalyticsDataClient.CreateAsync(); // Initialize request argument(s) MetadataName name = MetadataName.FromProperty("[PROPERTY]"); // Make the request Metadata response = await betaAnalyticsDataClient.GetMetadataAsync(name); }
public void Combine_should_qualify_member_with_type(SymbolType symbolType) { var actual = MetadataName.Combine( TypeName.Parse("String"), SymbolName.Parse("Length").ConvertTo(symbolType) ); Assert.Equal(symbolType, actual.SymbolType); Assert.Equal("String.Length", actual.FullName); }
/// <summary>Snippet for GetMetadata</summary> public void GetMetadataResourceNames() { // Snippet: GetMetadata(MetadataName, CallSettings) // Create client AlphaAnalyticsDataClient alphaAnalyticsDataClient = AlphaAnalyticsDataClient.Create(); // Initialize request argument(s) MetadataName name = MetadataName.FromMetadata(); // Make the request Metadata response = alphaAnalyticsDataClient.GetMetadata(name); // End snippet }
/// <summary>Snippet for GetMetadata</summary> public void GetMetadataResourceNames() { // Snippet: GetMetadata(MetadataName, CallSettings) // Create client BetaAnalyticsDataClient betaAnalyticsDataClient = BetaAnalyticsDataClient.Create(); // Initialize request argument(s) MetadataName name = MetadataName.FromProperty("[PROPERTY]"); // Make the request Metadata response = betaAnalyticsDataClient.GetMetadata(name); // End snippet }
public override int GetHashCode() { int hashCode = 0; unchecked { if (MetadataName != null) { hashCode += 1000000009 * MetadataName.GetHashCode(); } } return(hashCode); }
public DescriptionPackageIdentity( MetadataName name = null, UriBasedIdentifier publisherScopeId = null, Version version = null, bool isReadOnly = false) : base(isReadOnly : isReadOnly) { // _name = name; _publisherScopeId = publisherScopeId; _version = version; }
/// <summary>Snippet for GetMetadata</summary> /// <remarks> /// This snippet has been automatically generated for illustrative purposes only. /// It may require modifications to work in your environment. /// </remarks> public void GetMetadataRequestObject() { // Create client BetaAnalyticsDataClient betaAnalyticsDataClient = BetaAnalyticsDataClient.Create(); // Initialize request argument(s) GetMetadataRequest request = new GetMetadataRequest { MetadataName = MetadataName.FromProperty("[PROPERTY]"), }; // Make the request Metadata response = betaAnalyticsDataClient.GetMetadata(request); }
public void Combine_should_qualify_list_of_names() { var actual = MetadataName.Combine( AssemblyName.Parse("mscorlib"), NamespaceName.Parse("System"), TypeName.Parse("String"), TypeName.Parse("Enumerator") ); Assert.Equal(SymbolType.Type, actual.SymbolType); Assert.Equal("System.String+Enumerator, mscorlib", ((TypeName)actual).AssemblyQualifiedName); }
/// <summary>Snippet for GetMetadataAsync</summary> /// <remarks> /// This snippet has been automatically generated for illustrative purposes only. /// It may require modifications to work in your environment. /// </remarks> public async Task GetMetadataRequestObjectAsync() { // Create client BetaAnalyticsDataClient betaAnalyticsDataClient = await BetaAnalyticsDataClient.CreateAsync(); // Initialize request argument(s) GetMetadataRequest request = new GetMetadataRequest { MetadataName = MetadataName.FromProperty("[PROPERTY]"), }; // Make the request Metadata response = await betaAnalyticsDataClient.GetMetadataAsync(request); }
/// <summary>Snippet for GetMetadata</summary> public void GetMetadataRequestObject() { // Snippet: GetMetadata(GetMetadataRequest, CallSettings) // Create client AlphaAnalyticsDataClient alphaAnalyticsDataClient = AlphaAnalyticsDataClient.Create(); // Initialize request argument(s) GetMetadataRequest request = new GetMetadataRequest { MetadataName = MetadataName.FromProperty("[PROPERTY]"), }; // Make the request Metadata response = alphaAnalyticsDataClient.GetMetadata(request); // End snippet }
/// <summary>Snippet for GetMetadataAsync</summary> public async Task GetMetadataResourceNamesAsync() { // Snippet: GetMetadataAsync(MetadataName, CallSettings) // Additional: GetMetadataAsync(MetadataName, CancellationToken) // Create client BetaAnalyticsDataClient betaAnalyticsDataClient = await BetaAnalyticsDataClient.CreateAsync(); // Initialize request argument(s) MetadataName name = MetadataName.FromProperty("[PROPERTY]"); // Make the request Metadata response = await betaAnalyticsDataClient.GetMetadataAsync(name); // End snippet }
/// <summary>Snippet for GetMetadataAsync</summary> public async Task GetMetadataRequestObjectAsync() { // Snippet: GetMetadataAsync(GetMetadataRequest, CallSettings) // Additional: GetMetadataAsync(GetMetadataRequest, CancellationToken) // Create client BetaAnalyticsDataClient betaAnalyticsDataClient = await BetaAnalyticsDataClient.CreateAsync(); // Initialize request argument(s) GetMetadataRequest request = new GetMetadataRequest { MetadataName = MetadataName.FromProperty("[PROPERTY]"), }; // Make the request Metadata response = await betaAnalyticsDataClient.GetMetadataAsync(request); // End snippet }
public static void GetName(this CustomAttributeDef ca, out MetadataName name, out MetadataName @namespace) { var ctor = ca.Constructor; if (ctor.IsMemberRef) { var cls = ctor.MemberRef.Class; if (cls.IsTypeRef) { name = cls.TypeRef.TypeName; @namespace = cls.TypeRef.TypeNamespace; } else { name = cls.TypeDef.Name; @namespace = cls.TypeDef.Namespace; } } else { var ctorDef = ctor.MethodDef; TypeDef typeDef = ctorDef.FindDeclaringType(); name = typeDef.Name; @namespace = typeDef.Namespace; } }
private static unsafe void TestAllPrefixes(string ns) { byte[] bytes = Encoding.UTF8.GetBytes(ns + '\0'); fixed (byte* fbytes = &bytes[0]) { MetadataNamePart name = new MetadataName(fbytes, null).GetExtent(); int dot = name.Length; while (true) { int nextDot = name.LastIndexOf((byte)'.', dot - 1, dot); Assert(nextDot == ns.LastIndexOf('.', dot - 1, dot)); dot = nextDot; if (dot < 0) { break; } Assert(name.GetPart(0, dot).ToString() == ns.Substring(0, dot)); Assert(name.GetPart(dot + 1).ToString() == ns.Substring(dot + 1)); } } }
public static bool TryParseMetadataNames(IEnumerable<string> values, out ImmutableArray<MetadataName> metadataNames) { ImmutableArray<MetadataName>.Builder builder = null; foreach (string value in values) { if (!MetadataName.TryParse(value, out MetadataName metadataName)) { WriteLine($"Unable to parse metadata name '{value}'.", Verbosity.Quiet); return false; } (builder ?? (builder = ImmutableArray.CreateBuilder<MetadataName>())).Add(metadataName); } metadataNames = builder?.ToImmutableArray() ?? ImmutableArray<MetadataName>.Empty; return true; }
public static CodeReference Create(MetadataName name) { if (name == null) { throw new ArgumentNullException("name"); } switch (name.SymbolType) { case SymbolType.Field: return(new FieldCodeReference(null, (FieldName)name)); case SymbolType.Property: return(new PropertyCodeReference(null, (PropertyName)name)); case SymbolType.Event: return(new EventCodeReference(null, (EventName)name)); case SymbolType.Method: return(new MethodCodeReference(null, (MethodName)name)); case SymbolType.Type: return(new TypeCodeReference(null, (TypeName)name)); case SymbolType.Namespace: return(new NamespaceCodeReference(null, (NamespaceName)name)); case SymbolType.Assembly: return(new AssemblyCodeReference(null, (AssemblyName)name)); case SymbolType.Unknown: case SymbolType.Module: case SymbolType.Resource: case SymbolType.Local: case SymbolType.Alias: case SymbolType.Attribute: case SymbolType.Parameter: case SymbolType.InternedLocation: default: throw DotNetFailure.NotSupportedCodeReferenceConversion("name"); } }
private static AssemblyName CreateAssemblyName(MetadataName name, MetadataName culture, Version version, AssemblyNameFlags flags, byte[] publicKeyOrToken) { var result = new AssemblyName(); result.Name = name.ToString(); if (!culture.IsEmpty) { result.CultureInfo = new CultureInfo(culture.ToString()); } result.Version = version; result.Flags = flags; if (publicKeyOrToken.Length != 0) { if ((result.Flags & AssemblyNameFlags.PublicKey) != 0) { result.SetPublicKey(publicKeyOrToken); } else { result.SetPublicKeyToken(publicKeyOrToken); } } return result; }
public unsafe void TestAllPrefixes(string ns) { byte[] bytes = Encoding.UTF8.GetBytes(ns + '\0'); fixed(byte *fbytes = &bytes[0]) { MetadataNamePart name = new MetadataName(fbytes, null).GetExtent(); int dot = name.Length; while (true) { int nextDot = name.LastIndexOf((byte)'.', dot - 1, dot); Assert.That(nextDot, Is.EqualTo(ns.LastIndexOf('.', dot - 1, dot))); dot = nextDot; if (dot < 0) { break; } Assert.That(name.GetPart(0, dot).ToString(), Is.EqualTo(ns.Substring(0, dot))); Assert.That(name.GetPart(dot + 1).ToString(), Is.EqualTo(ns.Substring(dot + 1))); } } }
public unsafe void TestPrefixSuffix(string str, char separator, string expectedPrefix, string expectedSuffix) { byte[] bytes = Encoding.UTF8.GetBytes(str + '\0'); fixed(byte *fbytes = &bytes[0]) { MetadataName name = new MetadataName(fbytes, null); MetadataNamePart prefix; MetadataNamePart suffix; MetadataNamePart extent = name.GetExtent(); int index = extent.IndexOf((byte)separator); Assert.That((index < 0), Is.EqualTo((expectedPrefix == null))); if (index >= 0) { prefix = extent.GetPart(0, index); Assert.That(prefix.ToString(), Is.EqualTo(expectedPrefix)); suffix = extent.GetPart(index + 1); Assert.That(suffix.ToString(), Is.EqualTo(expectedSuffix)); } } }
public DeclarationListOptions( IEnumerable <string> ignoredNames = null, bool indent = DefaultValues.Indent, string indentChars = DefaultValues.IndentChars, bool nestNamespaces = DefaultValues.NestNamespaces, bool newLineBeforeOpenBrace = DefaultValues.NewLineBeforeOpenBrace, bool emptyLineBetweenMembers = DefaultValues.EmptyLineBetweenMembers, bool formatBaseList = DefaultValues.FormatBaseList, bool formatConstraints = DefaultValues.FormatConstraints, bool formatParameters = DefaultValues.FormatParameters, bool splitAttributes = DefaultValues.SplitAttributes, bool includeAttributeArguments = DefaultValues.IncludeAttributeArguments, bool omitIEnumerable = DefaultValues.OmitIEnumerable, bool useDefaultLiteral = DefaultValues.UseDefaultLiteral, bool fullyQualifiedNames = DefaultValues.FullyQualifiedNames, DocumentationDepth depth = DefaultValues.Depth, DeclarationListParts ignoredParts = DeclarationListParts.None) { _ignoredMetadataNames = ignoredNames?.Select(name => MetadataName.Parse(name)).ToImmutableArray() ?? default; IgnoredNames = ignoredNames?.ToImmutableArray() ?? ImmutableArray <string> .Empty; Indent = indent; IndentChars = indentChars; NestNamespaces = nestNamespaces; NewLineBeforeOpenBrace = newLineBeforeOpenBrace; EmptyLineBetweenMembers = emptyLineBetweenMembers; FormatBaseList = formatBaseList; FormatConstraints = formatConstraints; FormatParameters = formatParameters; SplitAttributes = splitAttributes; IncludeAttributeArguments = includeAttributeArguments; OmitIEnumerable = omitIEnumerable; UseDefaultLiteral = useDefaultLiteral; FullyQualifiedNames = fullyQualifiedNames; Depth = depth; IgnoredParts = ignoredParts; }
private static unsafe void TestDict() { Dictionary<MetadataNamePart, int> dict = new Dictionary<MetadataNamePart, int>(); byte[] bytes = Encoding.UTF8.GetBytes("A.B.XXXXXXXXX" + '\0'); fixed (byte* fbytes = &bytes[0]) { MetadataName name = new MetadataName(fbytes, null); MetadataNamePart[] parts = new[] { MetadataNamePart.Empty, name.GetExtent(), name.GetExtent().GetPart(0, 1), name.GetExtent().GetPart(2, 1), name.GetExtent().GetPart(4, 6), }; for (int i = 0; i < parts.Length; i++) { dict.Add(parts[i], i); } Assert(dict.Count == parts.Length); for (int i = 0; i < parts.Length; i++) { int value; Assert(dict.TryGetValue(parts[i], out value)); Assert(value == i); } } }
protected DependenciesDescription(MetadataName name) : base(name) { }
public FrequencyLimitTriggerDescription(MetadataName name) : base(name) { }
private static unsafe void TestPrefixSuffix(string str, char separator, string expectedPrefix, string expectedSuffix) { byte[] bytes = Encoding.UTF8.GetBytes(str + '\0'); fixed (byte* fbytes = &bytes[0]) { MetadataName name = new MetadataName(fbytes, null); MetadataNamePart prefix; MetadataNamePart suffix; MetadataNamePart extent = name.GetExtent(); int index = extent.IndexOf((byte)separator); Assert((index < 0) == (expectedPrefix == null)); if (index >= 0) { prefix = extent.GetPart(0, index); Assert(prefix.ToString() == expectedPrefix); suffix = extent.GetPart(index + 1); Assert(suffix.ToString() == expectedSuffix); } } }
public DependencyResolutionSettingsDescription(MetadataName name) : base(name) { }
protected ValidCodeReference(string original, MetadataName name) { this.original = original; this.name = name; }
public XAppLocalPublisherDescription(MetadataName name) : base(name: name) { _useDefaultSettings = true; }
public static void TestTryParse3() { const string x = "+Foo"; Assert.False(MetadataName.TryParse(x, out MetadataName _)); }
private static unsafe void TestIndexOf(string str, char c, int expected) { byte[] bytes = Encoding.UTF8.GetBytes(str + '\0'); fixed (byte* fbytes = &bytes[0]) { MetadataName name = new MetadataName(fbytes, null); Assert(name.IndexOf(checked((byte)c)) == expected); } }
private static unsafe void TestEquals() { byte[] b1 = Encoding.UTF8.GetBytes("hello\0"); byte[] b2 = Encoding.UTF8.GetBytes("__hello__\0"); byte[] b3 = Encoding.UTF8.GetBytes("__hell\0"); byte[] b4 = Encoding.UTF8.GetBytes("\0"); fixed (byte* fb1 = &b1[0]) { MetadataName name = new MetadataName(fb1, null); Assert(name.Equals(b2, 2, 5)); Assert(!name.Equals(b2, 2, 6)); Assert(!name.Equals(b2, 2, 4)); Assert(!name.Equals(b2, 1, 4)); } fixed (byte* fb4 = &b4[0]) { MetadataName name = new MetadataName(fb4, null); Assert(name.Equals(b2, 2, 0)); Assert(!name.Equals(b2, 0, 1)); } }
private static unsafe void TestEmpty() { byte[] empty = new byte[] { 0 }; fixed (byte* fempty = &empty[0]) { MetadataName e = new MetadataName(fempty, null); Assert(e.Equals(MetadataName.Empty)); Assert(e.Equals(MetadataNamePart.Empty)); Assert(MetadataName.Empty.IsEmpty); Assert(MetadataName.Empty.GetHashCode() == e.GetHashCode()); Assert(MetadataName.Empty.Equals(e)); Assert(MetadataName.Empty.Equals(MetadataNamePart.Empty)); Assert(MetadataName.Empty.GetLength() == 0); Assert(MetadataName.Empty.ToString() == ""); Assert(MetadataName.Empty.GetExtent().Equals(MetadataNamePart.Empty)); Assert(MetadataNamePart.Empty.Length == 0); Assert(MetadataNamePart.Empty.Equals(e)); Assert(MetadataNamePart.Empty.Equals(MetadataName.Empty)); Assert(MetadataNamePart.Empty.GetPart(0).Equals((object)MetadataNamePart.Empty)); Assert(MetadataNamePart.Empty.GetPart(0).Equals(MetadataNamePart.Empty)); Assert(MetadataNamePart.Empty.GetPart(0, 0).Equals(MetadataNamePart.Empty)); Assert(MetadataNamePart.Empty.ToString() == ""); Assert(MetadataNamePart.Empty.IndexOf(1) == -1); Assert(MetadataNamePart.Empty.IndexOf(1, 0, 0) == -1); Assert(MetadataNamePart.Empty.LastIndexOf(1, 0, 0) == -1); Assert(MetadataNamePart.Empty.IndexOf(0) == -1); Assert(MetadataNamePart.Empty.IndexOf(0, 0, 0) == -1); Assert(MetadataNamePart.Empty.LastIndexOf(0, 0, 0) == -1); } }