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);
}
}
