content
stringlengths 5
1.04M
| avg_line_length
float64 1.75
12.9k
| max_line_length
int64 2
244k
| alphanum_fraction
float64 0
0.98
| licenses
sequence | repository_name
stringlengths 7
92
| path
stringlengths 3
249
| size
int64 5
1.04M
| lang
stringclasses 2
values |
|---|---|---|---|---|---|---|---|---|
namespace MassTransit.RabbitMqTransport.Integration
{
using System;
using System.Threading;
using System.Threading.Tasks;
using Configuration;
using Context;
using Contexts;
using GreenPipes;
using Pipeline;
using Topology;
using Topology.Settings;
using Transport;
using Transports;
public class ConnectionContextSupervisor :
TransportPipeContextSupervisor<ConnectionContext>,
IConnectionContextSupervisor
{
readonly IRabbitMqHostConfiguration _hostConfiguration;
readonly IRabbitMqTopologyConfiguration _topologyConfiguration;
public ConnectionContextSupervisor(IRabbitMqHostConfiguration hostConfiguration, IRabbitMqTopologyConfiguration topologyConfiguration)
: base(new ConnectionContextFactory(hostConfiguration))
{
_hostConfiguration = hostConfiguration;
_topologyConfiguration = topologyConfiguration;
}
public Uri NormalizeAddress(Uri address)
{
return new RabbitMqEndpointAddress(_hostConfiguration.HostAddress, address);
}
public Task<ISendTransport> CreateSendTransport(IModelContextSupervisor modelContextSupervisor, Uri address)
{
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
var endpointAddress = new RabbitMqEndpointAddress(_hostConfiguration.HostAddress, address);
TransportLogMessages.CreateSendTransport(endpointAddress);
var settings = _topologyConfiguration.Send.GetSendSettings(endpointAddress);
var brokerTopology = settings.GetBrokerTopology();
IPipe<ModelContext> configureTopology = new ConfigureTopologyFilter<SendSettings>(settings, brokerTopology).ToPipe();
return CreateSendTransport(modelContextSupervisor, configureTopology, settings.ExchangeName, endpointAddress);
}
public Task<ISendTransport> CreatePublishTransport<T>(IModelContextSupervisor modelContextSupervisor)
where T : class
{
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
IRabbitMqMessagePublishTopology<T> publishTopology = _topologyConfiguration.Publish.GetMessageTopology<T>();
var settings = publishTopology.GetSendSettings(_hostConfiguration.HostAddress);
var brokerTopology = publishTopology.GetBrokerTopology();
IPipe<ModelContext> configureTopology = new ConfigureTopologyFilter<SendSettings>(settings, brokerTopology).ToPipe();
var endpointAddress = settings.GetSendAddress(_hostConfiguration.HostAddress);
return CreateSendTransport(modelContextSupervisor, configureTopology, publishTopology.Exchange.ExchangeName, endpointAddress);
}
Task<ISendTransport> CreateSendTransport(IModelContextSupervisor modelContextSupervisor, IPipe<ModelContext> pipe, string exchangeName,
RabbitMqEndpointAddress endpointAddress)
{
var supervisor = new ModelContextSupervisor(modelContextSupervisor);
var delayedExchangeAddress = endpointAddress.GetDelayAddress();
var delaySettings = new RabbitMqDelaySettings(delayedExchangeAddress);
delaySettings.BindToExchange(exchangeName);
IPipe<ModelContext> delayPipe = new ConfigureTopologyFilter<DelaySettings>(delaySettings, delaySettings.GetBrokerTopology()).ToPipe();
var sendTransportContext = new SendTransportContext(_hostConfiguration, supervisor, pipe, exchangeName, delayPipe, delaySettings.ExchangeName);
var transport = new RabbitMqSendTransport(sendTransportContext);
modelContextSupervisor.AddSendAgent(transport);
return Task.FromResult<ISendTransport>(transport);
}
class SendTransportContext :
BaseSendTransportContext,
RabbitMqSendTransportContext
{
readonly IRabbitMqHostConfiguration _hostConfiguration;
public SendTransportContext(IRabbitMqHostConfiguration hostConfiguration, IModelContextSupervisor modelContextSupervisor,
IPipe<ModelContext> configureTopologyPipe, string exchange,
IPipe<ModelContext> delayConfigureTopologyPipe, string delayExchange)
: base(hostConfiguration)
{
_hostConfiguration = hostConfiguration;
ModelContextSupervisor = modelContextSupervisor;
ConfigureTopologyPipe = configureTopologyPipe;
Exchange = exchange;
DelayConfigureTopologyPipe = delayConfigureTopologyPipe;
DelayExchange = delayExchange;
}
public IPipe<ModelContext> ConfigureTopologyPipe { get; }
public IPipe<ModelContext> DelayConfigureTopologyPipe { get; }
public string DelayExchange { get; }
public string Exchange { get; }
public IModelContextSupervisor ModelContextSupervisor { get; }
public Task Send(IPipe<ModelContext> pipe, CancellationToken cancellationToken)
{
return _hostConfiguration.Retry(() => ModelContextSupervisor.Send(pipe, cancellationToken), ModelContextSupervisor, cancellationToken);
}
public void Probe(ProbeContext context)
{
}
}
}
}
| 41.335878 | 155 | 0.708587 | [
"ECL-2.0",
"Apache-2.0"
] | MathiasZander/ServiceFabricPerfomanceTest | src/Transports/MassTransit.RabbitMqTransport/Integration/ConnectionContextSupervisor.cs | 5,417 | C# |
// ==========================================================================
// Squidex Headless CMS
// ==========================================================================
// Copyright (c) Squidex UG (haftungsbeschraenkt)
// All rights reserved. Licensed under the MIT license.
// ==========================================================================
using System;
using System.Collections.Generic;
using System.Globalization;
using Newtonsoft.Json;
using Squidex.Infrastructure.Json.Objects;
#pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
namespace Squidex.Infrastructure.Json.Newtonsoft
{
public class JsonValueConverter : JsonConverter, ISupportedTypes
{
private readonly HashSet<Type> supportedTypes = new HashSet<Type>
{
typeof(IJsonValue),
typeof(JsonArray),
typeof(JsonBoolean),
typeof(JsonNull),
typeof(JsonNumber),
typeof(JsonObject),
typeof(JsonString)
};
public virtual IEnumerable<Type> SupportedTypes
{
get { return supportedTypes; }
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
return ReadJson(reader);
}
private static IJsonValue ReadJson(JsonReader reader)
{
switch (reader.TokenType)
{
case JsonToken.Comment:
reader.Read();
break;
case JsonToken.StartObject:
{
var result = JsonValue.Object();
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
var propertyName = reader.Value.ToString();
if (!reader.Read())
{
throw new JsonSerializationException("Unexpected end when reading Object.");
}
var value = ReadJson(reader);
result[propertyName] = value;
break;
case JsonToken.EndObject:
return result;
}
}
throw new JsonSerializationException("Unexpected end when reading Object.");
}
case JsonToken.StartArray:
{
var result = JsonValue.Array();
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.Comment:
break;
default:
var value = ReadJson(reader);
result.Add(value);
break;
case JsonToken.EndArray:
return result;
}
}
throw new JsonSerializationException("Unexpected end when reading Object.");
}
case JsonToken.Integer:
return JsonValue.Create((long)reader.Value);
case JsonToken.Float:
return JsonValue.Create((double)reader.Value);
case JsonToken.Boolean:
return JsonValue.Create((bool)reader.Value);
case JsonToken.Date:
return JsonValue.Create(((DateTime)reader.Value).ToString("yyyy-MM-ddTHH:mm:ssK", CultureInfo.InvariantCulture));
case JsonToken.String:
return JsonValue.Create(reader.Value.ToString());
case JsonToken.Null:
case JsonToken.Undefined:
return JsonValue.Null;
}
throw new NotSupportedException();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
WriteJson(writer, (IJsonValue)value);
}
private static void WriteJson(JsonWriter writer, IJsonValue value)
{
switch (value)
{
case JsonNull _:
writer.WriteNull();
break;
case JsonBoolean s:
writer.WriteValue(s.Value);
break;
case JsonString s:
writer.WriteValue(s.Value);
break;
case JsonNumber s:
if (s.Value % 1 == 0)
{
writer.WriteValue((long)s.Value);
}
else
{
writer.WriteValue(s.Value);
}
break;
case JsonArray array:
writer.WriteStartArray();
for (var i = 0; i < array.Count; i++)
{
WriteJson(writer, array[i]);
}
writer.WriteEndArray();
break;
case JsonObject obj:
writer.WriteStartObject();
foreach (var kvp in obj)
{
writer.WritePropertyName(kvp.Key);
WriteJson(writer, kvp.Value);
}
writer.WriteEndObject();
break;
}
}
public override bool CanConvert(Type objectType)
{
return supportedTypes.Contains(objectType);
}
}
}
| 33.983784 | 133 | 0.416733 | [
"MIT"
] | Avd6977/squidex | src/Squidex.Infrastructure/Json/Newtonsoft/JsonValueConverter.cs | 6,289 | C# |
// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.DotNet.VersionTools.Dependencies;
namespace Dotnet.Docker
{
/// <summary>
/// An IDependencyUpdater that will scan a Dockerfile for the .NET Core artifacts that are installed.
/// The updater will then retrieve and update the checksum sha used to validate the downloaded artifacts.
/// </summary>
public class DockerfileShaUpdater : FileRegexUpdater
{
private const string ChecksumsHostName = "dotnetclichecksums.blob.core.windows.net";
private const string ShaVariableGroupName = "shaVariable";
private const string ShaValueGroupName = "shaValue";
private static readonly Dictionary<string, string> s_shaCache = new Dictionary<string, string>();
private static readonly Dictionary<string, Dictionary<string, string>> s_releaseChecksumCache =
new Dictionary<string, Dictionary<string, string>>();
private static readonly Dictionary<string, string> s_urls = new Dictionary<string, string> {
{"powershell", "https://pwshtool.blob.core.windows.net/tool/$VERSION/PowerShell.$OS.$ARCH.$VERSION.nupkg"},
{"monitor", "https://dotnetcli.azureedge.net/dotnet/diagnostics/monitor5.0/dotnet-monitor.$VERSION.nupkg"},
{"runtime", "https://dotnetcli.azureedge.net/dotnet/Runtime/$VERSION/dotnet-runtime-$VERSION-$OS-$ARCH.$ARCHIVE_EXT"},
{"aspnet", "https://dotnetcli.azureedge.net/dotnet/aspnetcore/Runtime/$VERSION/aspnetcore-runtime-$VERSION-$OS-$ARCH.$ARCHIVE_EXT"},
{"sdk", "https://dotnetcli.azureedge.net/dotnet/Sdk/$VERSION/dotnet-sdk-$VERSION-$OS-$ARCH.$ARCHIVE_EXT"},
{"lzma", "https://dotnetcli.azureedge.net/dotnet/Sdk/$VERSION/nuGetPackagesArchive.lzma"}
};
private string _productName;
private string _dockerfileVersion;
private string _buildVersion;
private string _arch;
private string _os;
private Options _options;
private string _versions;
public DockerfileShaUpdater() : base()
{
}
public static IEnumerable<IDependencyUpdater> CreateUpdaters(
string productName, string dockerfileVersion, string repoRoot, Options options)
{
string versionsPath = System.IO.Path.Combine(repoRoot, Program.VersionsFilename);
string versions = File.ReadAllText(versionsPath);
// The format of the sha variable name is '<productName>|<dockerfileVersion>|<os>|<arch>|sha'.
// The 'os' and 'arch' segments are optional.
string shaVariablePattern =
$"\"(?<{ShaVariableGroupName}>{Regex.Escape(productName)}\\|{Regex.Escape(dockerfileVersion)}.*\\|sha)\":";
Regex shaVariableRegex = new Regex(shaVariablePattern);
return shaVariableRegex.Matches(versions)
.Select(match => match.Groups[ShaVariableGroupName].Value)
.Select(variable =>
{
Trace.TraceInformation($"Updating {variable}");
string[] parts = variable.Split('|');
DockerfileShaUpdater updater = new DockerfileShaUpdater()
{
_productName = productName,
_buildVersion = VersionUpdater.GetBuildVersion(productName, dockerfileVersion, versions),
_dockerfileVersion = dockerfileVersion,
_os = parts.Length >= 4 ? parts[2] : string.Empty,
_arch = parts.Length >= 5 ? parts[3] : string.Empty,
_options = options,
_versions = versions,
Path = versionsPath,
VersionGroupName = ShaValueGroupName
};
string archPattern = updater._arch == string.Empty ? string.Empty : "|" + updater._arch;
string osPattern = updater._os == string.Empty ? string.Empty : "|" + updater._os;
updater.Regex = new Regex(
$"{shaVariablePattern.Replace(".*", Regex.Escape(osPattern + archPattern))} \"(?<{ShaValueGroupName}>.*)\"");
return updater;
})
.ToArray();
}
protected override string TryGetDesiredValue(
IEnumerable<IDependencyInfo> dependencyBuildInfos, out IEnumerable<IDependencyInfo> usedBuildInfos)
{
IDependencyInfo productInfo = dependencyBuildInfos.First(info => info.SimpleName == _productName);
usedBuildInfos = new IDependencyInfo[] { productInfo };
string downloadUrl = s_urls[_productName]
.Replace("$ARCHIVE_EXT", _os.Contains("win") ? "zip" : "tar.gz")
.Replace("$VERSION", _buildVersion)
.Replace("$OS", _os)
.Replace("$ARCH", _arch)
.Replace("..", ".");
return GetArtifactShaAsync(downloadUrl).Result;
}
private async Task<string> GetArtifactShaAsync(string downloadUrl)
{
if (!s_shaCache.TryGetValue(downloadUrl, out string sha))
{
sha = await GetDotNetCliChecksumsShaAsync(downloadUrl)
?? await GetDotNetReleaseChecksumsShaAsync(downloadUrl)
?? await ComputeChecksumShaAsync(downloadUrl);
if (sha != null)
{
sha = sha.ToLowerInvariant();
s_shaCache.Add(downloadUrl, sha);
Trace.TraceInformation($"Retrieved sha '{sha}' for '{downloadUrl}'.");
}
else
{
Trace.TraceError($"Unable to retrieve sha for '{downloadUrl}'.");
}
}
return sha;
}
private async Task<string> ComputeChecksumShaAsync(string downloadUrl)
{
if (!_options.ComputeChecksums)
{
return null;
}
string sha = null;
Trace.TraceInformation($"Downloading '{downloadUrl}'.");
using (HttpClient client = new HttpClient())
using (HttpResponseMessage response = await client.GetAsync(downloadUrl))
{
if (response.IsSuccessStatusCode)
{
using (Stream httpStream = await response.Content.ReadAsStreamAsync())
using (SHA512 hash = SHA512.Create())
{
byte[] hashedInputBytes = hash.ComputeHash(httpStream);
StringBuilder stringBuilder = new StringBuilder(128);
foreach (byte b in hashedInputBytes)
{
stringBuilder.Append(b.ToString("X2"));
}
sha = stringBuilder.ToString();
}
}
else
{
Trace.TraceInformation($"Failed to download {downloadUrl}.");
}
}
return sha;
}
private async Task<string> GetDotNetCliChecksumsShaAsync(string productDownloadUrl)
{
string sha = null;
string shaExt = _productName.Contains("sdk", StringComparison.OrdinalIgnoreCase) ? ".sha" : ".sha512";
UriBuilder uriBuilder = new UriBuilder(productDownloadUrl)
{
Host = ChecksumsHostName
};
string shaUrl = uriBuilder.ToString() + shaExt;
Trace.TraceInformation($"Downloading '{shaUrl}'.");
using (HttpClient client = new HttpClient())
using (HttpResponseMessage response = await client.GetAsync(shaUrl))
{
if (response.IsSuccessStatusCode)
{
sha = await response.Content.ReadAsStringAsync();
}
else
{
Trace.TraceInformation($"Failed to find `dotnetclichecksums` sha");
}
}
return sha;
}
private async Task<string> GetDotNetReleaseChecksumsShaAsync(
string productDownloadUrl)
{
string buildVersion = _buildVersion;
// The release checksum file contains content for all products in the release (runtime, sdk, etc.)
// and is referenced by the runtime version.
if (_productName.Contains("sdk", StringComparison.OrdinalIgnoreCase) ||
_productName.Contains("aspnet", StringComparison.OrdinalIgnoreCase))
{
buildVersion = VersionUpdater.GetBuildVersion("runtime", _dockerfileVersion, _versions);
}
IDictionary<string, string> checksumEntries = await GetDotnetReleaseChecksums(buildVersion);
string installerFileName = productDownloadUrl.Substring(productDownloadUrl.LastIndexOf('/') + 1);
if (!checksumEntries.TryGetValue(installerFileName, out string sha))
{
Trace.TraceInformation($"Failed to find `{installerFileName}` sha");
}
return sha;
}
private static async Task<IDictionary<string, string>> GetDotnetReleaseChecksums(string version)
{
string uri = $"https://dotnetcli.blob.core.windows.net/dotnet/checksums/{version}-sha.txt";
if (s_releaseChecksumCache.TryGetValue(uri, out Dictionary<string, string> checksumEntries))
{
return checksumEntries;
}
checksumEntries = new Dictionary<string, string>();
s_releaseChecksumCache.Add(uri, checksumEntries);
Trace.TraceInformation($"Downloading '{uri}'.");
using (HttpClient client = new HttpClient())
using (HttpResponseMessage response = await client.GetAsync(uri))
{
if (response.IsSuccessStatusCode)
{
string checksums = await response.Content.ReadAsStringAsync();
string[] checksumLines = checksums.Replace("\r\n", "\n").Split("\n");
if (!checksumLines[0].StartsWith("Hash") || !string.IsNullOrEmpty(checksumLines[1]))
{
Trace.TraceError($"Checksum file is not in the expected format: {uri}");
}
for (int i = 2; i < checksumLines.Length - 1; i++)
{
string[] parts = checksumLines[i].Split(" ");
if (parts.Length != 2)
{
Trace.TraceError($"Checksum file is not in the expected format: {uri}");
}
string fileName = parts[1];
string checksum = parts[0];
checksumEntries.Add(fileName, checksum);
Trace.TraceInformation($"Parsed checksum '{checksum}' for '{fileName}'");
}
}
else
{
Trace.TraceInformation($"Failed to find dotnet release checksums");
}
}
return checksumEntries;
}
}
}
| 43.560886 | 144 | 0.565608 | [
"MIT"
] | HEskandari/dotnet-docker | eng/update-dependencies/DockerfileShaUpdater.cs | 11,805 | C# |
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Linq;
namespace Microsoft.TestCommon
{
public class RefTypeTestData<T> : TestData<T> where T : class
{
private Func<IEnumerable<T>> testDataProvider;
private Func<IEnumerable<T>> derivedTypeTestDataProvider;
private Func<IEnumerable<T>> knownTypeTestDataProvider;
public RefTypeTestData(Func<IEnumerable<T>> testDataProvider)
{
if (testDataProvider == null)
{
throw new ArgumentNullException("testDataProvider");
}
this.testDataProvider = testDataProvider;
this.RegisterTestDataVariation(TestDataVariations.WithNull, this.Type, GetNullTestData);
}
public RefTypeTestData(
Func<IEnumerable<T>> testDataProvider,
Func<IEnumerable<T>> derivedTypeTestDataProvider,
Func<IEnumerable<T>> knownTypeTestDataProvider)
: this(testDataProvider)
{
this.derivedTypeTestDataProvider = derivedTypeTestDataProvider;
if (this.derivedTypeTestDataProvider != null)
{
this.RegisterTestDataVariation(TestDataVariations.AsDerivedType, this.Type, this.GetTestDataAsDerivedType);
}
this.knownTypeTestDataProvider = knownTypeTestDataProvider;
if (this.knownTypeTestDataProvider != null)
{
this.RegisterTestDataVariation(TestDataVariations.AsKnownType, this.Type, this.GetTestDataAsDerivedKnownType);
}
}
public T GetNullTestData()
{
return null;
}
public IEnumerable<T> GetTestDataAsDerivedType()
{
if (this.derivedTypeTestDataProvider != null)
{
return this.derivedTypeTestDataProvider();
}
return Enumerable.Empty<T>();
}
public IEnumerable<T> GetTestDataAsDerivedKnownType()
{
if (this.knownTypeTestDataProvider != null)
{
return this.knownTypeTestDataProvider();
}
return Enumerable.Empty<T>();
}
protected override IEnumerable<T> GetTypedTestData()
{
return this.testDataProvider();
}
}
}
| 32.368421 | 133 | 0.618699 | [
"Apache-2.0"
] | Darth-Fx/AspNetMvcStack | OData/test/Microsoft.TestCommon/Microsoft/TestCommon/DataSets/RefTypeTestData.cs | 2,462 | C# |
// <copyright filename="DiApiConnection.cs" project="Framework">
// This file is licensed to you under the MIT License.
// Full license in the project root.
// </copyright>
namespace B1PP.Connections
{
using Common;
using Exceptions;
using SAPbouiCOM;
using DiCompany = SAPbobsCOM.Company;
/// <summary>
/// Provides a connection to the DI API only.
/// </summary>
internal class DiApiConnection : IDiApiConnection
{
private readonly DiApiConnectionSettings settings;
public DiCompany Company { get; private set; }
public bool Connected { get; private set; }
public DiApiConnection(DiApiConnectionSettings settings)
{
this.settings = settings ?? DiApiConnectionSettings.CreateEmptySettings();
}
public void Connect()
{
if (Connected)
{
return;
}
Company = settings.ToCompany();
int result = Company.Connect();
if (result != 0)
{
throw new ConnectionFailedException($"{result} {Company.GetLastErrorDescription()}");
}
Connected = true;
}
public void Disconnect()
{
if (!Connected)
{
return;
}
if (Company != null)
{
Company.Disconnect();
Utilities.Release(Company);
Company = null;
}
Connected = false;
}
}
} | 23.328358 | 101 | 0.52975 | [
"MIT"
] | laukiet78/SAPB1-C-SHARP | Framework/Connections/DiApiConnection.cs | 1,565 | C# |
/*
* Copyright 2010-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Do not modify this file. This file is generated from the health-2016-08-04.normal.json service model.
*/
using System;
using System.Collections.Generic;
using System.Xml.Serialization;
using System.Text;
using System.IO;
using System.Net;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
namespace Amazon.AWSHealth.Model
{
/// <summary>
/// The specified locale is not supported.
/// </summary>
#if !PCL && !NETSTANDARD
[Serializable]
#endif
public partial class UnsupportedLocaleException : AmazonAWSHealthException
{
/// <summary>
/// Constructs a new UnsupportedLocaleException with the specified error
/// message.
/// </summary>
/// <param name="message">
/// Describes the error encountered.
/// </param>
public UnsupportedLocaleException(string message)
: base(message) {}
/// <summary>
/// Construct instance of UnsupportedLocaleException
/// </summary>
/// <param name="message"></param>
/// <param name="innerException"></param>
public UnsupportedLocaleException(string message, Exception innerException)
: base(message, innerException) {}
/// <summary>
/// Construct instance of UnsupportedLocaleException
/// </summary>
/// <param name="innerException"></param>
public UnsupportedLocaleException(Exception innerException)
: base(innerException) {}
/// <summary>
/// Construct instance of UnsupportedLocaleException
/// </summary>
/// <param name="message"></param>
/// <param name="innerException"></param>
/// <param name="errorType"></param>
/// <param name="errorCode"></param>
/// <param name="requestId"></param>
/// <param name="statusCode"></param>
public UnsupportedLocaleException(string message, Exception innerException, ErrorType errorType, string errorCode, string requestId, HttpStatusCode statusCode)
: base(message, innerException, errorType, errorCode, requestId, statusCode) {}
/// <summary>
/// Construct instance of UnsupportedLocaleException
/// </summary>
/// <param name="message"></param>
/// <param name="errorType"></param>
/// <param name="errorCode"></param>
/// <param name="requestId"></param>
/// <param name="statusCode"></param>
public UnsupportedLocaleException(string message, ErrorType errorType, string errorCode, string requestId, HttpStatusCode statusCode)
: base(message, errorType, errorCode, requestId, statusCode) {}
#if !PCL && !NETSTANDARD
/// <summary>
/// Constructs a new instance of the UnsupportedLocaleException class with serialized data.
/// </summary>
/// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
/// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="info" /> parameter is null. </exception>
/// <exception cref="T:System.Runtime.Serialization.SerializationException">The class name is null or <see cref="P:System.Exception.HResult" /> is zero (0). </exception>
protected UnsupportedLocaleException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
: base(info, context)
{
}
/// <summary>
/// Sets the <see cref="T:System.Runtime.Serialization.SerializationInfo" /> with information about the exception.
/// </summary>
/// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
/// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="info" /> parameter is a null reference (Nothing in Visual Basic). </exception>
#if BCL35
[System.Security.Permissions.SecurityPermission(
System.Security.Permissions.SecurityAction.LinkDemand,
Flags = System.Security.Permissions.SecurityPermissionFlag.SerializationFormatter)]
#endif
[System.Security.SecurityCritical]
// These FxCop rules are giving false-positives for this method
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2134:MethodsMustOverrideWithConsistentTransparencyFxCopRule")]
public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
{
base.GetObjectData(info, context);
}
#endif
}
} | 47.314516 | 178 | 0.680245 | [
"Apache-2.0"
] | JeffAshton/aws-sdk-net | sdk/src/Services/AWSHealth/Generated/Model/UnsupportedLocaleException.cs | 5,867 | C# |
// Copyright (c) Josef Pihrt. All rights reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
namespace Roslynator.CodeMetrics
{
internal class CodeMetricsOptions
{
public CodeMetricsOptions(
bool includeGenerated = false,
bool includeWhitespace = false,
bool includeComments = false,
bool includePreprocessorDirectives = false,
bool ignoreBlockBoundary = false)
{
IncludeGeneratedCode = includeGenerated;
IncludeWhitespace = includeWhitespace;
IncludeComments = includeComments;
IncludePreprocessorDirectives = includePreprocessorDirectives;
IgnoreBlockBoundary = ignoreBlockBoundary;
}
public static CodeMetricsOptions Default { get; } = new CodeMetricsOptions();
public bool IncludeGeneratedCode { get; }
public bool IncludeWhitespace { get; }
public bool IncludeComments { get; }
public bool IncludePreprocessorDirectives { get; }
public bool IgnoreBlockBoundary { get; }
}
}
| 34.058824 | 160 | 0.66753 | [
"Apache-2.0"
] | Maxprofs/Roslynator | src/Core/CodeMetrics/CodeMetricsOptions.cs | 1,160 | C# |
namespace ZeroMQ.AcceptanceTests.ZmqSocketTests
{
using AcceptanceTests;
using NUnit.Framework;
[TestFixture]
public class WhenTransferringMultipartMessages : UsingThreadedReqRep
{
protected ZmqMessage Message;
protected SendStatus SendResult1;
protected SendStatus SendResult2;
public WhenTransferringMultipartMessages()
{
SenderAction = req =>
{
SendResult1 = SendResult2 = req.SendMessage(new ZmqMessage(new[] { Messages.MultiFirst, Messages.MultiLast }));
};
ReceiverAction = rep =>
{
Message = rep.ReceiveMessage();
};
}
[Test]
public void ShouldSendTheFirstMessageSuccessfully()
{
Assert.AreEqual(SendStatus.Sent, SendResult1);
}
[Test]
public void ShouldSendTheSecondMessageSuccessfully()
{
Assert.AreEqual(SendStatus.Sent, SendResult2);
}
[Test]
public void ShouldReceiveAllMessageParts()
{
Assert.AreEqual(2, Message.FrameCount);
}
[Test]
public void ShouldContainTheCorrectFirstMessageData()
{
Assert.AreEqual(Messages.MultiFirst, Message.First);
}
[Test]
public void ShouldHaveMorePartsAfterTheFirstMessage()
{
Assert.IsTrue(Message.First.HasMore);
}
[Test]
public void ShouldContainTheCorrectSecondMessageData()
{
Assert.AreEqual(Messages.MultiLast, Message.Last);
}
[Test]
public void ShouldNotHaveMorePartsAfterTheSecondMessage()
{
Assert.IsFalse(Message.Last.HasMore);
}
[Test]
public void ShouldBeACompleteMessage()
{
Assert.IsTrue(Message.IsComplete);
}
[Test]
public void ShouldNotBeAnEmptyMessage()
{
Assert.IsFalse(Message.IsEmpty);
}
[Test]
public void ShouldContainTheCorrectNumberOfFrames()
{
Assert.AreEqual(2, Message.FrameCount);
}
[Test]
public void ShouldContainTheCorrectNumberOfBytes()
{
Assert.AreEqual(Messages.MultiFirst.MessageSize + Messages.MultiLast.MessageSize, Message.TotalSize);
}
}
}
| 25.817204 | 127 | 0.582257 | [
"MIT"
] | JoeyJiao/peach | 3rdParty/clrzmq/src/ZeroMQ.AcceptanceTests/ZmqSocketTests/SendMessage_ReceiveMessage.cs | 2,403 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using ZWave.Channel;
using ZWave.Channel.Protocol;
namespace ZWave.CommandClasses
{
public class BatteryReport : NodeReport
{
public readonly byte Value;
public readonly bool IsLow;
internal BatteryReport(Node node, byte[] payload) : base(node)
{
if (payload == null)
throw new ArgumentNullException(nameof(payload));
if (payload.Length < 1)
throw new ReponseFormatException($"The response was not in the expected format. {GetType().Name}: Payload: {BitConverter.ToString(payload)}");
IsLow = payload[0] == 0xFF;
Value = IsLow ? (byte)0x00 : payload[0];
}
public override string ToString()
{
return IsLow ? "Low" : $"Value:{Value}%";
}
}
}
| 28.387097 | 158 | 0.602273 | [
"Apache-2.0"
] | AdamoT/ZWave4Net | ZWave/CommandClasses/BatteryReport.cs | 882 | C# |
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using Calabonga.TicTac.Resx;
namespace Calabonga.TicTac.Web.Models
{
public class ExternalLoginConfirmationViewModel
{
[Required]
[Display(ResourceType = typeof (Resource), Name = "Email"), ]
public string Email { get; set; }
}
public class ExternalLoginListViewModel
{
public string ReturnUrl { get; set; }
}
public class SendCodeViewModel
{
public string SelectedProvider { get; set; }
public ICollection<System.Web.Mvc.SelectListItem> Providers { get; set; }
public string ReturnUrl { get; set; }
public bool RememberMe { get; set; }
}
public class VerifyCodeViewModel
{
[Required]
public string Provider { get; set; }
[Required]
[Display(ResourceType = typeof (Resource), Name = "Code")]
public string Code { get; set; }
public string ReturnUrl { get; set; }
[Display(ResourceType = typeof (Resource), Name = "RememberBrowser")]
public bool RememberBrowser { get; set; }
public bool RememberMe { get; set; }
}
public class ForgotViewModel
{
[Required]
[Display(ResourceType = typeof (Resource), Name = "Email")]
public string Email { get; set; }
}
public class LoginViewModel
{
[Required]
[Display(ResourceType = typeof (Resource), Name = "Email")]
[EmailAddress]
public string Email { get; set; }
[Required]
[DataType(DataType.Password)]
[Display(ResourceType = typeof (Resource), Name = "Password")]
public string Password { get; set; }
[Display(ResourceType = typeof (Resource), Name = "RememberMe")]
public bool RememberMe { get; set; }
}
public class RegisterViewModel
{
[Required]
[EmailAddress]
[Display(ResourceType = typeof (Resource), Name = "Email")]
public string Email { get; set; }
[Required]
[StringLength(100, ErrorMessageResourceType = typeof (Resource), ErrorMessageResourceName = "PasswordCharactersLong", MinimumLength = 6)]
[DataType(DataType.Password)]
[Display(ResourceType = typeof (Resource), Name = "Password")]
public string Password { get; set; }
[DataType(DataType.Password)]
[Display(ResourceType = typeof (Resource), Name = "ConfirmPassword")]
[Compare("Password", ErrorMessageResourceType = typeof (Resource), ErrorMessageResourceName = "ConfirmPasswordNotMatch")]
public string ConfirmPassword { get; set; }
}
public class ResetPasswordViewModel
{
[Required]
[EmailAddress]
[Display(ResourceType = typeof (Resource), Name = "Email")]
public string Email { get; set; }
[Required]
[StringLength(100, ErrorMessageResourceType = typeof (Resource), ErrorMessageResourceName = "PasswordCharactersLong", MinimumLength = 6)]
[DataType(DataType.Password)]
[Display(ResourceType = typeof (Resource), Name = "Password")]
public string Password { get; set; }
[DataType(DataType.Password)]
[Display(ResourceType = typeof (Resource), Name = "ConfirmPassword")]
[Compare("Password", ErrorMessageResourceType = typeof (Resource), ErrorMessageResourceName = "ConfirmPasswordNotMatch")]
public string ConfirmPassword { get; set; }
public string Code { get; set; }
}
public class ForgotPasswordViewModel
{
[Required]
[EmailAddress]
[Display(ResourceType = typeof (Resource), Name = "Email")]
public string Email { get; set; }
}
}
| 32.833333 | 145 | 0.630243 | [
"MIT"
] | Calabonga/Tic-Tac-Toe | Tic-Tac-Toe/Calabonga.TicTac.Web/Models/AccountViewModels.cs | 3,745 | C# |
using System.Threading.Tasks;
namespace Fileicsh.Abstraction
{
/// <inheritdoc />
/// <summary>
/// An abstraction of an authenticated file that can calculate
/// the file's hash.
/// </summary>
public interface IAuthenticatedFile : IFile
{
/// <summary>
/// The hash algorithm used to calculate the hash of the file.
/// </summary>
string HashAlgorithm { get; }
/// <summary>
/// Returns the hash of the file as a byte array.
/// </summary>
/// <returns>A <see cref="Task{TResult}"/> containing the hash of the file as a byte array.</returns>
Task<byte[]> GetHashAsync();
}
}
| 28.5 | 109 | 0.584795 | [
"MIT"
] | Ekenstein/Fileicsh | Fileicsh.Abstraction/IAuthenticatedFile.cs | 686 | C# |
// ***********************************************************************
// Assembly : IronyModManager.Models
// Author : Mario
// Created : 05-29-2020
//
// Last Modified By : Mario
// Last Modified On : 10-01-2020
// ***********************************************************************
// <copyright file="GameSettings.cs" company="Mario">
// Mario
// </copyright>
// <summary></summary>
// ***********************************************************************
using System.Collections.Generic;
using System;
using IronyModManager.Models.Common;
namespace IronyModManager.Models
{
/// <summary>
/// Class GameSettings.
/// Implements the <see cref="IronyModManager.Models.Common.BaseModel" />
/// Implements the <see cref="IronyModManager.Models.Common.IGameSettings" />
/// </summary>
/// <seealso cref="IronyModManager.Models.Common.BaseModel" />
/// <seealso cref="IronyModManager.Models.Common.IGameSettings" />
public class GameSettings : BaseModel, IGameSettings
{
#region Properties
/// <summary>
/// Gets or sets a value indicating whether [close application after game launch].
/// </summary>
/// <value><c>null</c> if [close application after game launch] contains no value, <c>true</c> if [close application after game launch]; otherwise, <c>false</c>.</value>
public virtual bool? CloseAppAfterGameLaunch { get; set; }
/// <summary>
/// Gets or sets the executable location.
/// </summary>
/// <value>The executable location.</value>
public virtual string ExecutableLocation { get; set; }
/// <summary>
/// Gets or sets the launch arguments.
/// </summary>
/// <value>The launch arguments.</value>
public virtual string LaunchArguments { get; set; }
/// <summary>
/// Gets or sets a value indicating whether [refresh descriptors].
/// </summary>
/// <value><c>true</c> if [refresh descriptors]; otherwise, <c>false</c>.</value>
public virtual bool RefreshDescriptors { get; set; }
/// <summary>
/// Gets or sets the type.
/// </summary>
/// <value>The type.</value>
public virtual string Type { get; set; }
/// <summary>
/// Gets or sets the data directory.
/// </summary>
/// <value>The data directory.</value>
public virtual string UserDirectory { get; set; }
#endregion Properties
}
}
| 36.357143 | 177 | 0.550491 | [
"MIT"
] | LunarTraveller/IronyModManager | src/IronyModManager.Models/GameSettings.cs | 2,547 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using Bib3;
using BotEngine.Interface;
using Sanderling.ABot.Bot.Memory;
using Sanderling.ABot.Bot.Task;
using Sanderling.ABot.Serialization;
using Sanderling.Accumulator;
using Sanderling.Interface.MemoryStruct;
using Sanderling.Motor;
using Sanderling.Parse;
using IMemoryMeasurement = Sanderling.Parse.IMemoryMeasurement;
using IShipUiModule = Sanderling.Accumulation.IShipUiModule;
namespace Sanderling.ABot.Bot
{
public class Bot
{
public static readonly Func<long> GetTimeMilli = Glob.StopwatchZaitMiliSictInt;
public readonly MemoryMeasurementAccumulator MemoryMeasurementAccu = new MemoryMeasurementAccumulator();
private readonly IDictionary<long, int> MouseClickLastStepIndexFromUIElementId = new Dictionary<long, int>();
public readonly OverviewMemory OverviewMemory = new OverviewMemory();
private readonly IDictionary<IShipUiModule, int> ToggleLastStepIndexFromModule =
new Dictionary<IShipUiModule, int>();
private int motionId;
private int stepIndex;
public bool OwnAnomaly { private set; get; }
public bool SkipAnomaly { private set; get; }
public BotStepInput StepLastInput { private set; get; }
public PropertyGenTimespanInt64<BotStepResult> StepLastResult { private set; get; }
public FromProcessMeasurement<IMemoryMeasurement> MemoryMeasurementAtTime { private set; get; }
public KeyValuePair<Deserialization, Config> ConfigSerialAndStruct { private set; get; }
public long? MouseClickLastAgeStepCountFromUIElement(IUIElement uiElement)
{
if (null == uiElement)
return null;
var interactionLastStepIndex = MouseClickLastStepIndexFromUIElementId?.TryGetValueNullable(uiElement.Id);
return stepIndex - interactionLastStepIndex;
}
public long? ToggleLastAgeStepCountFromModule(IShipUiModule module)
{
return stepIndex - ToggleLastStepIndexFromModule?.TryGetValueNullable(module);
}
public void SetOwnAnomaly(bool value)
{
OwnAnomaly = value;
}
public void SetSkipAnomaly(bool value)
{
SkipAnomaly = value;
}
private IEnumerable<IBotTask[]> StepOutputListTaskPath()
{
return ((IBotTask) new BotTask {Component = RootTaskListComponent()})
?.EnumeratePathToNodeFromTreeDFirst(node => node?.Component)
?.Where(taskPath => (taskPath?.LastOrDefault()).ShouldBeIncludedInStepOutput())
?.TakeSubsequenceWhileUnwantedInferenceRuledOut();
}
private void MemorizeStepInput(BotStepInput input)
{
ConfigSerialAndStruct = (input?.ConfigSerial?.String).DeserializeIfDifferent(ConfigSerialAndStruct);
MemoryMeasurementAtTime =
input?.FromProcessMemoryMeasurement?.MapValue(measurement => measurement?.Parse());
MemoryMeasurementAccu.Accumulate(MemoryMeasurementAtTime);
OverviewMemory.Aggregate(MemoryMeasurementAtTime);
}
private void MemorizeStepResult(BotStepResult stepResult)
{
var setMotionMouseWaypointUIElement =
stepResult?.ListMotion
?.Select(motion => motion?.MotionParam)
?.Where(motionParam => 0 < motionParam?.MouseButton?.Count())
?.Select(motionParam => motionParam?.MouseListWaypoint)
?.ConcatNullable()?.Select(mouseWaypoint => mouseWaypoint?.UIElement)?.WhereNotDefault();
foreach (var mouseWaypointUIElement in setMotionMouseWaypointUIElement.EmptyIfNull())
MouseClickLastStepIndexFromUIElementId[mouseWaypointUIElement.Id] = stepIndex;
}
public BotStepResult Step(BotStepInput input)
{
var beginTimeMilli = GetTimeMilli();
StepLastInput = input;
Exception exception = null;
var listMotion = new List<MotionRecommendation>();
IBotTask[][] outputListTaskPath = null;
try
{
MemorizeStepInput(input);
outputListTaskPath = StepOutputListTaskPath()?.ToArray();
foreach (var moduleToggle in outputListTaskPath.ConcatNullable().OfType<ModuleToggleTask>()
.Select(moduleToggleTask => moduleToggleTask?.module).WhereNotDefault())
ToggleLastStepIndexFromModule[moduleToggle] = stepIndex;
foreach (var taskPath in outputListTaskPath.EmptyIfNull())
foreach (var effectParam in (taskPath?.LastOrDefault()?.ApplicableEffects()).EmptyIfNull())
listMotion.Add(new MotionRecommendation
{
Id = motionId++,
MotionParam = effectParam
});
}
catch (Exception e)
{
exception = e;
}
var stepResult = new BotStepResult
{
Exception = exception,
ListMotion = listMotion?.ToArrayIfNotEmpty(),
OutputListTaskPath = outputListTaskPath
};
MemorizeStepResult(stepResult);
StepLastResult = new PropertyGenTimespanInt64<BotStepResult>(stepResult, beginTimeMilli, GetTimeMilli());
++stepIndex;
return stepResult;
}
private IEnumerable<IBotTask> RootTaskListComponent()
{
return StepLastInput?.RootTaskListComponentOverride ??
RootTaskListComponentDefault();
}
private IEnumerable<IBotTask> RootTaskListComponentDefault()
{
yield return new BotTask {Component = EnumerateConfigDiagnostics()};
yield return new EnableInfoPanelCurrentSystem {MemoryMeasurement = MemoryMeasurementAtTime?.Value};
var saveShipTask = new SaveShipTask {Bot = this};
yield return saveShipTask;
yield return this.EnsureIsActive(
MemoryMeasurementAccu?.ShipUiModule?.Where(module => module.ShouldBeActivePermanent(this)));
var moduleUnknown =
MemoryMeasurementAccu?.ShipUiModule?.FirstOrDefault(module => null == module?.TooltipLast?.Value);
yield return new BotTask {Effects = new[] {moduleUnknown?.MouseMove()}};
if (!saveShipTask.AllowRoam)
yield break;
var combatTask = new CombatTask {bot = this};
yield return combatTask;
if (!saveShipTask.AllowAnomalyEnter)
yield break;
yield return new UndockTask {MemoryMeasurement = MemoryMeasurementAtTime?.Value};
if (combatTask.Completed)
yield return new AnomalyEnter {bot = this};
}
private IEnumerable<IBotTask> EnumerateConfigDiagnostics()
{
var configDeserializeException = ConfigSerialAndStruct.Key?.Exception;
if (null != configDeserializeException)
yield return new DiagnosticTask
{MessageText = "error parsing configuration: " + configDeserializeException.Message};
else if (null == ConfigSerialAndStruct.Value)
yield return new DiagnosticTask {MessageText = "warning: no configuration supplied."};
}
}
} | 30.960976 | 111 | 0.761462 | [
"Apache-2.0"
] | SDManson/A-Bot-ORBIT-Player-Detection | src/Sanderling.ABot/Bot/Bot.cs | 6,349 | C# |
namespace Interpretators.Expressions.PropertyNames
{
using Models.Enums;
public class BoxSizingType : PropertyName
{
public BoxSizingType() : base(CssPropertyType.BoxSizing)
{
}
}
} | 20.181818 | 64 | 0.657658 | [
"MIT"
] | kraskoo/CssAnimationSerializer | CssSerialization/Interpretators/Expressions/PropertyNames/BoxSizingType.cs | 222 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace ApiRestNetCore
{
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
}
}
| 25.777778 | 70 | 0.646552 | [
"Apache-2.0"
] | vidapogosoft/CursoWebApiRest-WebServices072020 | ApiRestNetCore/Program.cs | 696 | C# |
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Graphics.Imaging;
using Windows.Storage;
namespace UwpPdf
{
class ImageUtils
{
///////////////////////////////////////////////////////////////////////////////////////////
// from https://gist.github.com/alexsorokoletov/56a120c5562344d60e1a6b3fa75bda2c
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Resizes and crops source file image so that resized image width/height are not larger than <param name="requestedMinSide"></param>
/// </summary>
/// <param name="sourceFile">Source StorageFile</param>
/// <param name="requestedMinSide">Width/Height of the output image</param>
/// <param name="resizedImageFile">Target StorageFile</param>
/// <returns></returns>
private async Task<IStorageFile> CreateThumbnaiImage(StorageFile sourceFile, int requestedMinSide, StorageFile resizedImageFile)
{
var imageStream = await sourceFile.OpenReadAsync();
var decoder = await BitmapDecoder.CreateAsync(imageStream);
var originalPixelWidth = decoder.PixelWidth;
var originalPixelHeight = decoder.PixelHeight;
using (imageStream)
{
//do resize only if needed
if (originalPixelHeight > requestedMinSide && originalPixelWidth > requestedMinSide)
{
using (var resizedStream = await resizedImageFile.OpenAsync(FileAccessMode.ReadWrite))
{
//create encoder based on decoder of the source file
var encoder = await BitmapEncoder.CreateForTranscodingAsync(resizedStream, decoder);
double widthRatio = (double)requestedMinSide / originalPixelWidth;
double heightRatio = (double)requestedMinSide / originalPixelHeight;
uint aspectHeight = (uint)requestedMinSide;
uint aspectWidth = (uint)requestedMinSide;
uint cropX = 0, cropY = 0;
var scaledSize = (uint)requestedMinSide;
if (originalPixelWidth > originalPixelHeight)
{
aspectWidth = (uint)(heightRatio * originalPixelWidth);
cropX = (aspectWidth - aspectHeight) / 2;
}
else
{
aspectHeight = (uint)(widthRatio * originalPixelHeight);
cropY = (aspectHeight - aspectWidth) / 2;
}
//you can adjust interpolation and other options here, so far linear is fine for thumbnails
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Linear;
encoder.BitmapTransform.ScaledHeight = aspectHeight;
encoder.BitmapTransform.ScaledWidth = aspectWidth;
encoder.BitmapTransform.Bounds = new BitmapBounds()
{
Width = scaledSize,
Height = scaledSize,
X = cropX,
Y = cropY,
};
await encoder.FlushAsync();
}
}
else
{
//otherwise just use source file as thumbnail
await sourceFile.CopyAndReplaceAsync(resizedImageFile);
}
}
return resizedImageFile;
}
/// <summary>
/// Converts source image file to jpeg of defined quality (0.85)
/// </summary>
/// <param name="sourceFile">Source StorageFile</param>
/// <param name="outputFile">Target StorageFile</param>
/// <returns></returns>
private async Task<StorageFile> ConvertImageToJpegAsync(StorageFile sourceFile, StorageFile outputFile)
{
//you can use WinRTXamlToolkit StorageItemExtensions.GetSizeAsync to get file size (if you already plugged this nuget in)
var sourceFileProperties = await sourceFile.GetBasicPropertiesAsync();
var fileSize = sourceFileProperties.Size;
var imageStream = await sourceFile.OpenReadAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
using (imageStream)
{
var decoder = await BitmapDecoder.CreateAsync(imageStream);
var pixelData = await decoder.GetPixelDataAsync();
var detachedPixelData = pixelData.DetachPixelData();
pixelData = null;
//0.85d
//double jpegImageQuality = Constants.ImageAttachStartingImageQuality;
double jpegImageQuality = 0.9;
//since we're using MvvmCross, we're outputing diagnostic info to MvxTrace, you can use System.Diagnostics.Debug.WriteLine instead
//Mvx.TaggedTrace(MvxTraceLevel.Diagnostic, "ImageService", $"Source image size: {fileSize}, trying Q={jpegImageQuality}");
var imageWriteableStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite);
ulong jpegImageSize = 0;
using (imageWriteableStream)
{
var propertySet = new BitmapPropertySet();
var qualityValue = new BitmapTypedValue(jpegImageQuality, Windows.Foundation.PropertyType.Single);
propertySet.Add("ImageQuality", qualityValue);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, imageWriteableStream, propertySet);
//key thing here is to use decoder.OrientedPixelWidth and decoder.OrientedPixelHeight otherwise you will get garbled image on devices on some photos with orientation in metadata
encoder.SetPixelData(decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, decoder.OrientedPixelWidth, decoder.OrientedPixelHeight, decoder.DpiX, decoder.DpiY, detachedPixelData);
await encoder.FlushAsync();
await imageWriteableStream.FlushAsync();
jpegImageSize = imageWriteableStream.Size;
}
//Mvx.TaggedTrace(MvxTraceLevel.Diagnostic, "ImageService", $"Final image size now: {jpegImageSize}");
}
stopwatch.Stop();
//Mvx.TaggedTrace(MvxTraceLevel.Diagnostic, "ImageService", $"Time spent optimizing image: {stopwatch.Elapsed}");
return outputFile;
}
}
}
| 51.37037 | 197 | 0.56943 | [
"MIT"
] | diegotonetti99/pdf-uwp | UwpPdf/ImageUtils.cs | 6,937 | C# |
// *** WARNING: this file was generated by the Pulumi SDK Generator. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Pulumi.Serialization;
namespace Pulumi.AzureNextGen.Network.V20180801.Outputs
{
[OutputType]
public sealed class BackendAddressPoolResponse
{
/// <summary>
/// Gets collection of references to IP addresses defined in network interfaces.
/// </summary>
public readonly ImmutableArray<Outputs.NetworkInterfaceIPConfigurationResponse> BackendIPConfigurations;
/// <summary>
/// A unique read-only string that changes whenever the resource is updated.
/// </summary>
public readonly string? Etag;
/// <summary>
/// Resource ID.
/// </summary>
public readonly string? Id;
/// <summary>
/// Gets load balancing rules that use this backend address pool.
/// </summary>
public readonly ImmutableArray<Outputs.SubResourceResponse> LoadBalancingRules;
/// <summary>
/// Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
/// </summary>
public readonly string? Name;
/// <summary>
/// Gets outbound rules that use this backend address pool.
/// </summary>
public readonly Outputs.SubResourceResponse OutboundRule;
/// <summary>
/// Gets outbound rules that use this backend address pool.
/// </summary>
public readonly ImmutableArray<Outputs.SubResourceResponse> OutboundRules;
/// <summary>
/// Get provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
/// </summary>
public readonly string? ProvisioningState;
[OutputConstructor]
private BackendAddressPoolResponse(
ImmutableArray<Outputs.NetworkInterfaceIPConfigurationResponse> backendIPConfigurations,
string? etag,
string? id,
ImmutableArray<Outputs.SubResourceResponse> loadBalancingRules,
string? name,
Outputs.SubResourceResponse outboundRule,
ImmutableArray<Outputs.SubResourceResponse> outboundRules,
string? provisioningState)
{
BackendIPConfigurations = backendIPConfigurations;
Etag = etag;
Id = id;
LoadBalancingRules = loadBalancingRules;
Name = name;
OutboundRule = outboundRule;
OutboundRules = outboundRules;
ProvisioningState = provisioningState;
}
}
}
| 35.974359 | 123 | 0.642908 | [
"Apache-2.0"
] | pulumi/pulumi-azure-nextgen | sdk/dotnet/Network/V20180801/Outputs/BackendAddressPoolResponse.cs | 2,806 | C# |
/* Copyright (c) Citrix Systems, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms,
* with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above
* copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using Moq;
using NUnit.Framework;
using XenAdmin.Alerts;
using XenAdmin.Core;
using XenAdmin.Network;
using XenAdminTests.UnitTests.UnitTestHelper;
using XenAPI;
namespace XenAdminTests.UnitTests.AlertTests
{
[TestFixture, Category(TestCategories.Unit)]
public class XenServerUpdateAlertTests
{
private Mock<IXenConnection> connA;
private Mock<IXenConnection> connB;
private Mock<Host> hostA;
private Mock<Host> hostB;
protected Cache cacheA;
protected Cache cacheB;
[Test]
public void TestAlertWithConnectionAndHosts()
{
XenServerVersion ver = new XenServerVersion("1.2.3", "name", true, false, "http://url", new List<XenServerPatch>(), new List<XenServerPatch>(), new DateTime(2011, 4, 1).ToString(), "123", "", false, "");
var alert = new XenServerVersionAlert(ver);
alert.IncludeConnection(connA.Object);
alert.IncludeConnection(connB.Object);
alert.IncludeHosts(new List<Host>() { hostA.Object, hostB.Object });
IUnitTestVerifier validator = new VerifyGetters(alert);
validator.Verify(new AlertClassUnitTestData
{
AppliesTo = "HostAName, HostBName, ConnAName, ConnBName",
FixLinkText = "Go to Web Page",
HelpID = "XenServerUpdateAlert",
Description = "name is now available. Download the latest at the " + XenAdmin.Branding.COMPANY_NAME_SHORT + " website.",
HelpLinkText = "Help",
Title = "name is now available",
Priority = "Priority5"
});
Assert.IsFalse(alert.CanIgnore);
VerifyConnExpectations(Times.Once);
VerifyHostsExpectations(Times.Once);
}
[Test]
public void TestAlertWithHostsAndNoConnection()
{
XenServerVersion ver = new XenServerVersion("1.2.3", "name", true, false, "http://url", new List<XenServerPatch>(), new List<XenServerPatch>(), new DateTime(2011, 4, 1).ToString(), "123", "", false, "");
var alert = new XenServerVersionAlert(ver);
alert.IncludeHosts(new List<Host> { hostA.Object, hostB.Object });
IUnitTestVerifier validator = new VerifyGetters(alert);
validator.Verify(new AlertClassUnitTestData
{
AppliesTo = "HostAName, HostBName",
FixLinkText = "Go to Web Page",
HelpID = "XenServerUpdateAlert",
Description = "name is now available. Download the latest at the " + XenAdmin.Branding.COMPANY_NAME_SHORT + " website.",
HelpLinkText = "Help",
Title = "name is now available",
Priority = "Priority5"
});
Assert.IsFalse(alert.CanIgnore);
VerifyConnExpectations(Times.Never);
VerifyHostsExpectations(Times.Once);
}
[Test]
public void TestAlertWithConnectionAndNoHosts()
{
XenServerVersion ver = new XenServerVersion("1.2.3", "name", true, false, "http://url", new List<XenServerPatch>(), new List<XenServerPatch>(), new DateTime(2011, 4, 1).ToString(), "123", "", false, "");
var alert = new XenServerVersionAlert(ver);
alert.IncludeConnection(connA.Object);
alert.IncludeConnection(connB.Object);
IUnitTestVerifier validator = new VerifyGetters(alert);
validator.Verify(new AlertClassUnitTestData
{
AppliesTo = "ConnAName, ConnBName",
FixLinkText = "Go to Web Page",
HelpID = "XenServerUpdateAlert",
Description = "name is now available. Download the latest at the " + XenAdmin.Branding.COMPANY_NAME_SHORT + " website.",
HelpLinkText = "Help",
Title = "name is now available",
Priority = "Priority5"
});
Assert.IsFalse(alert.CanIgnore);
VerifyConnExpectations(Times.Once);
VerifyHostsExpectations(Times.Never);
}
[Test]
public void TestAlertWithNoConnectionAndNoHosts()
{
XenServerVersion ver = new XenServerVersion("1.2.3", "name", true, false, "http://url", new List<XenServerPatch>(), new List<XenServerPatch>(), new DateTime(2011, 4, 1).ToString(), "123", "", false, "");
var alert = new XenServerVersionAlert(ver);
IUnitTestVerifier validator = new VerifyGetters(alert);
validator.Verify(new AlertClassUnitTestData
{
AppliesTo = string.Empty,
FixLinkText = "Go to Web Page",
HelpID = "XenServerUpdateAlert",
Description = "name is now available. Download the latest at the " + XenAdmin.Branding.COMPANY_NAME_SHORT + " website.",
HelpLinkText = "Help",
Title = "name is now available",
Priority = "Priority5"
});
Assert.IsTrue(alert.CanIgnore);
VerifyConnExpectations(Times.Never);
VerifyHostsExpectations(Times.Never);
}
[Test]
public void TestAlertWithNullVersion()
{
Assert.That(()=> new XenServerVersionAlert(null), Throws.Exception.With.TypeOf(typeof(NullReferenceException)));
}
private void VerifyConnExpectations(Func<Times> times)
{
connA.Verify(n => n.Name, times());
connB.Verify(n => n.Name, times());
}
private void VerifyHostsExpectations(Func<Times> times)
{
hostA.Verify(n => n.Name(), times());
hostB.Verify(n => n.Name(), times());
}
[SetUp]
public void TestSetUp()
{
connA = new Mock<IXenConnection>(MockBehavior.Strict);
connA.Setup(n => n.Name).Returns("ConnAName");
cacheA = new Cache();
connA.Setup(x => x.Cache).Returns(cacheA);
connB = new Mock<IXenConnection>(MockBehavior.Strict);
connB.Setup(n => n.Name).Returns("ConnBName");
cacheB = new Cache();
connB.Setup(x => x.Cache).Returns(cacheB);
hostA = new Mock<Host>(MockBehavior.Strict);
hostA.Setup(n => n.Name()).Returns("HostAName");
hostA.Setup(n => n.Equals(It.IsAny<object>())).Returns((object o) => ReferenceEquals(o, hostA.Object));
hostB = new Mock<Host>(MockBehavior.Strict);
hostB.Setup(n => n.Name()).Returns("HostBName");
hostB.Setup(n => n.Equals(It.IsAny<object>())).Returns((object o) => ReferenceEquals(o, hostB.Object));
}
[TearDown]
public void TestTearDown()
{
cacheA = null;
cacheB = null;
connA = null;
connB = null;
hostA = null;
hostB = null;
}
}
} | 41.042453 | 216 | 0.590507 | [
"BSD-2-Clause"
] | DoNnMyTh/xenadmin | XenAdminTests/UnitTests/AlertTests/XenServerUpdateAlertTests.cs | 8,701 | C# |
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
namespace Mockaco.Templating.Generating.Source
{
internal class SourceContentProviderComposite : ISourceContentProvider
{
private readonly IServiceProvider _serviceProvider;
private readonly IDictionary<Predicate<Uri>, Type> _providersRegistry = new Dictionary<Predicate<Uri>, Type>();
public SourceContentProviderComposite(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
RegisterDefaultProviders();
}
private void RegisterDefaultProviders()
{
Register(uri => uri.Scheme.Equals(Uri.UriSchemeFile) || Path.IsPathFullyQualified(uri.OriginalString), typeof(LocalFileContentProvider));
Register(uri => uri.Scheme.Equals(Uri.UriSchemeHttp) || uri.Scheme.Equals(Uri.UriSchemeHttps), typeof(HttpContentProvider));
}
private ISourceContentProvider Create(Uri sourceUri)
{
foreach (var registryItem in _providersRegistry)
{
var canHandle = registryItem.Key;
var providerType = registryItem.Value;
if (canHandle(sourceUri))
{
return (ISourceContentProvider)Activator.CreateInstance(registryItem.Value);
}
}
throw new NotSupportedException("Specified URI is not supported");
}
public void Register(Predicate<Uri> canHandle, Type type)
{
_providersRegistry.Add(canHandle, type);
}
public Task<Stream> GetStreamAsync(Uri sourceUri, CancellationToken cancellationToken)
{
var specificProvider = Create(sourceUri);
return specificProvider.GetStreamAsync(sourceUri, cancellationToken);
}
}
}
| 35.563636 | 149 | 0.663088 | [
"Apache-2.0"
] | atyminski/Mockaco | src/Mockaco.AspNetCore/Templating/Generating/Source/SourceContentProviderComposite.cs | 1,958 | C# |
using HMI.Vehicles.Services;
using UnityEngine;
namespace HMI.Vehicles.Behaviours
{
/// <summary>
/// Controls the vehicle
/// </summary>
public class VehicleController : MonoBehaviour
{
/// <summary>
/// Switch vehicle to next gear
/// </summary>
public void NextGear()
{
VehicleService.GetTransmission().SwitchToNextGear();
}
/// <summary>
/// Switch vehicle to previous gear
/// </summary>
public void PreviousGear()
{
VehicleService.GetTransmission().SwitchToPreviousGear();
}
/// <summary>
/// Accelerate vehicle
/// </summary>
public void Accelerate()
{
VehicleService.GetVehicle().Accelerate(1f);
}
/// <summary>
/// Brake vehicle
/// </summary>
public void Brake()
{
VehicleService.GetVehicle().Brake(1f);
}
/// <summary>
/// Start/Stop Engine
/// </summary>
public static void StartStopEngine()
{
var engine = VehicleService.GetEngine();
if(engine.IsEngineOn)
{
engine.TurnEngineOff();
}
else
{
engine.TurnEngineOn();
}
}
/// <summary>
/// Increase ADAS goal speed
/// </summary>
public static void AdasIncreaseGoalSpeed()
{
VehicleService.GetSpeedController().IncreaseGoalSpeed();
}
/// <summary>
/// Decrease ADAS goal speed
/// </summary>
public static void AdasDecreaseGoalSpeed()
{
VehicleService.GetSpeedController().DecreaseGoalSpeed();
}
/// <summary>
/// Set ADAS
/// </summary>
public static void AdasSet()
{
VehicleService.GetSpeedController().SetAutomaticSpeedControl();
}
/// <summary>
/// Cancel ADAS command
/// </summary>
public static void AdasCancel()
{
VehicleService.GetSpeedController().CancelAutomaticSpeedControl();
}
}
}
| 24.010753 | 78 | 0.502911 | [
"MIT"
] | sunrui19941128/CarHMI | Assets/UnityTechnologies/HMITemplate/Scripts/HMI/Vehicles/Behaviours/VehicleController.cs | 2,235 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace OTHub.APIServer.Sql
{
public class DataCreatorsSql
{
public static string GetDataCreatorsSql(string userID, bool filterByMyNodes)
{
var data = $@"select substring(I.NodeId, 1, 40) as NodeId,
MAX(VERSION) Version,
{(userID != null ? "x.DisplayName as DisplayName," : "")}
SUM(COALESCE(I.Stake, 0)) as StakeTokens,
SUM(COALESCE(I.StakeReserved, 0)) as StakeReservedTokens,
x.Timestamp as CreatedTimestamp,
p.OffersTotal,
p.OffersLast7Days,
p.AvgDataSetSizeKB,
p.AvgHoldingTimeInMinutes,
p.AvgTokenAmountPerHolder,
p.LastJob
from OTIdentity I
LEFT JOIN (SELECT
O.DCnodeID,
Count(O.OfferId) OffersTotal,
SUM(CASE WHEN O.CreatedTimestamp >= Date_Add(NOW(), INTERVAL -7 DAY) THEN 1 ELSE 0 END) OffersLast7Days,
ROUND(AVG(O.DataSetSizeInBytes) / 1000) AvgDataSetSizeKB,
ROUND(AVG(O.HoldingTimeInMinutes)) AvgHoldingTimeInMinutes,
ROUND(AVG(O.TokenAmountPerHolder)) AvgTokenAmountPerHolder,
COALESCE(MAX(O.FinalizedTimestamp), MAX(CreatedTimestamp)) LastJob
FROM otoffer O GROUP BY O.DCNodeId) p ON p.DCnodeID = I.NodeID
JOIN (SELECT I.Identity, COALESCE(PCB.Timestamp, ICB.Timestamp) as Timestamp {(userID != null ? ", MN.DisplayName" : "")} FROM OTIdentity I
{(userID != null ? $"{(filterByMyNodes ? "INNER" : "LEFT")} JOIN MyNodes MN ON MN.NodeID = I.NodeID AND MN.UserID = @userID" : "")}
LEFT JOIN OTContract_Profile_ProfileCreated PC ON PC.Profile = I.Identity AND PC.BlockchainID = I.BlockchainID
LEFT JOIN EthBlock PCB ON PCB.BlockNumber = PC.BlockNumber AND PCB.BlockchainID = I.BlockchainID
LEFT JOIN OTContract_Profile_IdentityCreated IC ON IC.NewIdentity = I.Identity AND IC.BlockchainID = I.BlockchainID
LEFT JOIN EthBlock ICB ON ICB.BlockNumber = IC.BlockNumber AND ICB.BlockchainID = I.BlockchainID
WHERE IC.NewIdentity is not null OR PC.Profile is not null) x on x.Identity = I.Identity
WHERE Version = 1
AND (@NodeId_like is null OR I.NodeId = @NodeId_like)
GROUP BY I.NodeId";
return data;
}
public static string GetDataCreatorsCountSql(string userID, bool filterByMyNodes)
{
return $@"select COUNT(DISTINCT I.NodeId)
from OTIdentity I
{(userID != null ? $"{(filterByMyNodes ? "INNER" : "LEFT")} JOIN MyNodes MN ON MN.NodeID = I.NodeID AND MN.UserID = @userID" : "")}
JOIN (SELECT I.Identity, COALESCE(PCB.Timestamp, ICB.Timestamp) as Timestamp FROM OTIdentity I
LEFT JOIN OTContract_Profile_ProfileCreated PC ON PC.Profile = I.Identity AND PC.BlockchainID = I.BlockchainID
LEFT JOIN EthBlock PCB ON PCB.BlockNumber = PC.BlockNumber AND PCB.BlockchainID = I.BlockchainID
LEFT JOIN OTContract_Profile_IdentityCreated IC ON IC.NewIdentity = I.Identity AND IC.BlockchainID = I.BlockchainID
LEFT JOIN EthBlock ICB ON ICB.BlockNumber = IC.BlockNumber AND ICB.BlockchainID = I.BlockchainID
WHERE IC.NewIdentity is not null OR PC.Profile is not null) x on x.Identity = I.Identity
WHERE Version = 1
AND (@NodeId_like is null OR I.NodeId = @NodeId_like)";
}
}
} | 48.793651 | 139 | 0.75309 | [
"MIT"
] | OT-Hub/OTHub | OTHub.ApiServer/Sql/DataCreatorsSql.cs | 3,076 | C# |
namespace LH.TestObjects.Compare
{
using System;
internal class ValueComparisonAdapter<TProp> : IValueComparison<TProp>
{
private readonly ValueComparison comparison;
private readonly ComparisonContext context;
public ValueComparisonAdapter(ValueComparison comparison, ComparisonContext context)
{
this.comparison = comparison;
this.context = context;
}
object IValueComparison.ExpectedValue
{
get { return this.comparison.ExpectedValue; }
}
public TProp ExpectedValue
{
get { return (TProp)this.comparison.ExpectedValue; }
}
object IValueComparison.ActualValue
{
get { return this.comparison.ActualValue; }
}
string IValueComparison<TProp>.Message
{
get { return this.comparison.Message; }
set { this.comparison.Message = value; }
}
public Type PropertyType
{
get { return this.comparison.PropertyType; }
}
public string PropertyName
{
get { return this.comparison.PropertyName; }
}
public TProp ActualValue
{
get { return (TProp)this.comparison.ActualValue; }
}
public string PropertyPath
{
get { return this.comparison.PropertyPath; }
}
public string Message
{
get { return this.comparison.Message; }
}
public bool CompareItem(object expected, object actual, string propertyName)
{
var propertyPath = new PropertyPathItem(propertyName, this.comparison.PropertyPathItem, false);
return this.context.CompareItem(expected, actual, propertyPath);
}
}
} | 26.867647 | 107 | 0.591133 | [
"MIT"
] | lholota/LH.TestObjects | LH.TestObjects/Compare/ValueComparisonAdapter.cs | 1,827 | C# |
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
namespace my_aspcore_realworld
{
#pragma warning disable CA1052 // Static holder types should be Static or NotInheritable
public static class Program
#pragma warning restore CA1052 // Static holder types should be Static or NotInheritable
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
}
}
| 31.913043 | 89 | 0.626703 | [
"MIT"
] | rizaramadan/my-aspcore-realworld | my-aspcore-realworld/Program.cs | 734 | C# |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("UnitTestingWebAPI.Tests")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("UnitTestingWebAPI.Tests")]
[assembly: AssemblyCopyright("Copyright © 2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("0d2b4c59-fefa-4fdd-b4d6-0a94721c94b1")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
| 38.351351 | 84 | 0.74771 | [
"MIT"
] | chsakell/webapiunittesting | UnitTestingWebAPI.Tests/Properties/AssemblyInfo.cs | 1,422 | C# |
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Text;
using TestHelper;
namespace Microsoft.Azure.WebJobs.Extensions.DurableTask.Analyzers.Test.Orchestrator
{
[TestClass]
public class MethodAnalyzerTests : CodeFixVerifier
{
private static readonly string DiagnosticId = MethodAnalyzer.DiagnosticId;
private static readonly DiagnosticSeverity Severity = MethodAnalyzer.Severity;
[TestMethod]
public void MethodCallsInOrchestrator_NonIssueCalls()
{
var test = @"
using System;
using System.Collections.Generic;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
namespace VSSample
{
public static class HelloSequence
{
[FunctionName(""E1_HelloSequence"")]
public static async Task<List<string>> Run(
[OrchestrationTrigger] IDurableOrchestrationContext context)
{
string.ToLower(""Testing method call not defined in source code"");
DirectCall();
return ""Hello"";
}
public static string DirectCall()
{
string.ToUpper(""Method not defined in source code"");
IndirectCall();
return ""Hi"";
}
public static Object IndirectCall()
{
return new Object();
}
}
}";
VerifyCSharpDiagnostic(test);
}
[TestMethod]
public void MethodCallsInOrchestrator_DirectCall()
{
var test = @"
using System;
using System.Collections.Generic;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
namespace VSSample
{
public static class HelloSequence
{
[FunctionName(""E1_HelloSequence"")]
public static async Task<List<string>> Run(
[OrchestrationTrigger] IDurableOrchestrationContext context)
{
DirectCall();
return ""Hello"";
}
public static string DirectCall()
{
var dateTime = DateTime.Now;
return ""Hi"";
}
}
}";
var expectedDiagnostics = new DiagnosticResult[2];
expectedDiagnostics[0] = new DiagnosticResult
{
Id = DiagnosticId,
Message = string.Format(Resources.MethodAnalyzerMessageFormat, "DirectCall()"),
Severity = Severity,
Locations =
new[] {
new DiagnosticResultLocation("Test0.cs", 17, 17)
}
};
expectedDiagnostics[1] = new DiagnosticResult
{
Id = DateTimeAnalyzer.DiagnosticId,
Message = string.Format(Resources.DeterministicAnalyzerMessageFormat, "DateTime.Now"),
Severity = Severity,
Locations =
new[] {
new DiagnosticResultLocation("Test0.cs", 24, 28)
}
};
VerifyCSharpDiagnostic(test, expectedDiagnostics);
}
[TestMethod]
public void MethodCallsInOrchestrator_IndirectCall()
{
var test = @"
using System;
using System.Collections.Generic;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
namespace VSSample
{
public static class HelloSequence
{
[FunctionName(""E1_HelloSequence"")]
public static async Task<List<string>> Run(
[OrchestrationTrigger] IDurableOrchestrationContext context)
{
DirectCall();
return ""Hello"";
}
public static string DirectCall()
{
IndirectCall();
return ""Hi"";
}
public static Object IndirectCall()
{
var dateTime = DateTime.Now;
return new Object();
}
}
}";
var expectedDiagnostics = new DiagnosticResult[3];
expectedDiagnostics[0] = new DiagnosticResult
{
Id = DiagnosticId,
Message = string.Format(Resources.MethodAnalyzerMessageFormat, "DirectCall()"),
Severity = Severity,
Locations =
new[] {
new DiagnosticResultLocation("Test0.cs", 17, 17)
}
};
expectedDiagnostics[1] = new DiagnosticResult
{
Id = DiagnosticId,
Message = string.Format(Resources.MethodAnalyzerMessageFormat, "IndirectCall()"),
Severity = Severity,
Locations =
new[] {
new DiagnosticResultLocation("Test0.cs", 24, 13)
}
};
expectedDiagnostics[2] = new DiagnosticResult
{
Id = DateTimeAnalyzer.DiagnosticId,
Message = string.Format(Resources.DeterministicAnalyzerMessageFormat, "DateTime.Now"),
Severity = Severity,
Locations =
new[] {
new DiagnosticResultLocation("Test0.cs", 30, 28)
}
};
VerifyCSharpDiagnostic(test, expectedDiagnostics);
}
[TestMethod]
public void MethodCallsInOrchestrator_NonShortCircuit()
{
var test = @"
using System;
using System.Collections.Generic;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
namespace VSSample
{
public static class HelloSequence
{
[FunctionName(""E1_HelloSequence"")]
public static async Task<List<string>> Run(
[OrchestrationTrigger] IDurableOrchestrationContext context)
{
DirectCall();
return ""Hello"";
}
public static string DirectCall()
{
var dateTime = DateTime.Now;
Environment.GetEnvironmentVariable(""test"");
return ""Hi"";
}
}
}";
var expectedDiagnostics = new DiagnosticResult[3];
expectedDiagnostics[0] = new DiagnosticResult
{
Id = DiagnosticId,
Message = string.Format(Resources.MethodAnalyzerMessageFormat, "DirectCall()"),
Severity = Severity,
Locations =
new[] {
new DiagnosticResultLocation("Test0.cs", 17, 17)
}
};
expectedDiagnostics[1] = new DiagnosticResult
{
Id = DateTimeAnalyzer.DiagnosticId,
Message = string.Format(Resources.DeterministicAnalyzerMessageFormat, "DateTime.Now"),
Severity = Severity,
Locations =
new[] {
new DiagnosticResultLocation("Test0.cs", 24, 28)
}
};
expectedDiagnostics[2] = new DiagnosticResult
{
Id = EnvironmentVariableAnalyzer.DiagnosticId,
Message = string.Format(Resources.DeterministicAnalyzerMessageFormat, "Environment.GetEnvironmentVariable"),
Severity = Severity,
Locations =
new[] {
new DiagnosticResultLocation("Test0.cs", 25, 13)
}
};
VerifyCSharpDiagnostic(test, expectedDiagnostics);
}
protected override DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()
{
return new OrchestratorAnalyzer();
}
}
}
| 30.560886 | 124 | 0.552644 | [
"MIT"
] | Fabian-Schmidt/azure-functions-durable-extension | test/WebJobs.Extensions.DurableTask.Analyzers.Test/Orchestrator/MethodAnalyzerTests.cs | 8,284 | C# |
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace DemonsSoulsSaveOrganizer.Properties {
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "16.6.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
public static Settings Default {
get {
return defaultInstance;
}
}
[global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("")]
public string SavefileDirectory {
get {
return ((string)(this["SavefileDirectory"]));
}
set {
this["SavefileDirectory"] = value;
}
}
[global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("")]
public string ProfilesDirectory {
get {
return ((string)(this["ProfilesDirectory"]));
}
set {
this["ProfilesDirectory"] = value;
}
}
[global::System.Configuration.ApplicationScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("https://github.com/NaxHPL/DemonsSoulsSaveOrganizer")]
public string GithubRepository {
get {
return ((string)(this["GithubRepository"]));
}
}
[global::System.Configuration.ApplicationScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("https://twitter.com/NaxHPL")]
public string TwitterLink {
get {
return ((string)(this["TwitterLink"]));
}
}
[global::System.Configuration.ApplicationScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("https://github.com/NaxHPL/DemonsSoulsSaveOrganizer#demons-souls-save-organizer")]
public string HelpLink {
get {
return ((string)(this["HelpLink"]));
}
}
[global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("False")]
public bool GlobalHotkeysEnabled {
get {
return ((bool)(this["GlobalHotkeysEnabled"]));
}
set {
this["GlobalHotkeysEnabled"] = value;
}
}
[global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("0")]
public int LoadSavestateHotkey {
get {
return ((int)(this["LoadSavestateHotkey"]));
}
set {
this["LoadSavestateHotkey"] = value;
}
}
[global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("0")]
public int SortByIndex {
get {
return ((int)(this["SortByIndex"]));
}
set {
this["SortByIndex"] = value;
}
}
}
}
| 39.72807 | 151 | 0.584677 | [
"MIT"
] | NaxHPL/DemonsSoulsSaveOrganizer | DemonsSoulsSaveOrganizer/Properties/Settings.Designer.cs | 4,531 | C# |
/*
Copyright 2012 Michael Edwards
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
//-CRE-
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Glass.Mapper.Pipelines.DataMapperResolver;
using Glass.Mapper.Sc.Configuration;
using Sitecore.Data;
using Sitecore.Data.Fields;
using Sitecore.Data.Items;
namespace Glass.Mapper.Sc.DataMappers
{
/// <summary>
/// Class SitecoreFieldTypeMapper
/// </summary>
public class SitecoreFieldTypeMapper : AbstractSitecoreFieldMapper
{
/// <summary>
/// Gets the field value.
/// </summary>
/// <param name="fieldValue">The field value.</param>
/// <param name="config">The config.</param>
/// <param name="context">The context.</param>
/// <returns>System.Object.</returns>
public override object GetFieldValue(string fieldValue, SitecoreFieldConfiguration config, SitecoreDataMappingContext context)
{
var item = context.Item;
if (fieldValue.IsNullOrEmpty()) return null;
Guid id = Guid.Empty;
Item target;
if (Guid.TryParse(fieldValue, out id)) {
target = item.Database.GetItem(new ID(id), item.Language);
}
else
{
target = item.Database.GetItem(fieldValue, item.Language);
}
if (target == null) return null;
return context.Service.CreateType(config.PropertyInfo.PropertyType, target, IsLazy, InferType, null);
}
/// <summary>
/// Sets the field value.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="config">The config.</param>
/// <param name="context">The context.</param>
/// <returns>System.String.</returns>
/// <exception cref="System.NullReferenceException">Could not find item to save value {0}.Formatted(Configuration)</exception>
public override string SetFieldValue(object value, SitecoreFieldConfiguration config, SitecoreDataMappingContext context)
{
if (context == null)
throw new ArgumentNullException("context", "The context was incorrectly set");
if(context.Service == null)
throw new NullReferenceException("The context's service property was null");
if (context.Service.GlassContext == null)
throw new NullReferenceException("The service glass context is null");
if (context.Service.Database == null)
throw new NullReferenceException("The database is not set for the service");
if (value == null)
return string.Empty;
var type = value.GetType();
var typeConfig = context.Service.GlassContext.GetTypeConfiguration<SitecoreTypeConfiguration>(value);
if(typeConfig == null)
throw new NullReferenceException("The type {0} has not been loaded into context {1}".Formatted(type.FullName, context.Service.GlassContext.Name));
var item = typeConfig.ResolveItem(value, context.Service.Database);
if(item == null)
throw new NullReferenceException("Could not find item to save value {0}".Formatted(Configuration));
return item.ID.ToString();
}
/// <summary>
/// Determines whether this instance can handle the specified configuration.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="context">The context.</param>
/// <returns><c>true</c> if this instance can handle the specified configuration; otherwise, <c>false</c>.</returns>
public override bool CanHandle(Mapper.Configuration.AbstractPropertyConfiguration configuration, Context context)
{
return configuration is SitecoreFieldConfiguration;// context[configuration.PropertyInfo.PropertyType] != null &&
}
/// <summary>
/// Sets up the data mapper for a particular property
/// </summary>
/// <param name="args">The args.</param>
public override void Setup(DataMapperResolverArgs args)
{
var scConfig = args.PropertyConfiguration as SitecoreFieldConfiguration;
IsLazy = (scConfig.Setting & SitecoreFieldSettings.DontLoadLazily) != SitecoreFieldSettings.DontLoadLazily;
InferType = (scConfig.Setting & SitecoreFieldSettings.InferType) == SitecoreFieldSettings.InferType;
base.Setup(args);
}
/// <summary>
/// Gets or sets a value indicating whether [infer type].
/// </summary>
/// <value><c>true</c> if [infer type]; otherwise, <c>false</c>.</value>
protected bool InferType { get; set; }
/// <summary>
/// Gets or sets a value indicating whether this instance is lazy.
/// </summary>
/// <value><c>true</c> if this instance is lazy; otherwise, <c>false</c>.</value>
protected bool IsLazy { get; set; }
}
}
| 38.080537 | 162 | 0.629714 | [
"MIT"
] | kgkostadinov/TdsTesting | packages/Glass.Mapper.Sc.4.0.7.56/src/Source/Glass.Mapper.Sc/DataMappers/SitecoreFieldTypeMapper.cs | 5,674 | C# |
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Globalization;
using System.IO;
using System.Net;
using System.Text.RegularExpressions;
using System.Web;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Media;
using WpfUtils;
namespace Display.ViewModels.Twitter
{
public class TweetViewModel
: BaseViewModel
{
private readonly ObservableCollection<TweetSection> _writableContents;
internal TweetViewModel(TwitterViewModel.StatusResponse status)
{
if (status == null)
throw new ArgumentNullException("status");
Created = DateTime.ParseExact(status.CreatedAt,
"ddd MMM dd HH:mm:ss zzz yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.AdjustToUniversal);;
var elapsed = DateTime.UtcNow - Created;
CreatedElapsed = elapsed.TotalMinutes < 60
? elapsed.Minutes + "m"
: (int)Math.Floor(elapsed.TotalHours) + "h";
Name = status.User.Name;
ScreenName = status.User.ScreenName;
_writableContents = new ObservableCollection<TweetSection>();
Contents = new ReadOnlyObservableCollection<TweetSection>(_writableContents);
ParseTweet(status);
}
public DateTime Created { get; private set; }
public string CreatedElapsed { get; private set; }
public string ScreenName { get; private set; }
public string Name { get; private set; }
public ReadOnlyObservableCollection<TweetSection> Contents { get; private set; }
public TextBlock ReplyingTo { get; private set; }
public TextBlock FormattedText { get; private set; }
public SolidColorBrush BackgroundColour { get; private set; }
public string ProfileImagePath { get; set; }
private void ParseTweet(TwitterViewModel.StatusResponse status)
{
if (status.Entities == null)
{
_writableContents.Add(new TweetSection(status.FullText, TweetSectionType.Text));
return;
}
var tweetSections = new List<TweetSection>();
tweetSections.Add(new TweetSection(status.FullText, TweetSectionType.Text));
// Add all the HashTag sections
foreach (var hashTag in status.Entities.Hashtags.OrderByDescending(ht => ht.Text.Length))
{
UpdateListOfSections(hashTag.Text, TweetSectionType.HashTag, tweetSections);
}
// Add all the UserMention sections
foreach (var userMention in status.Entities.UserMentions.OrderByDescending(um => um.ScreenName.Length))
{
UpdateListOfSections(userMention.ScreenName, TweetSectionType.UserMention, tweetSections);
}
// Unescape strings
for (var i = 0; i < tweetSections.Count; i++)
{
var section = tweetSections[i];
if (section.Type != TweetSectionType.Text)
continue;
tweetSections[i] = new TweetSection(HttpUtility.HtmlDecode(section.Text), TweetSectionType.Text);
}
_writableContents.AddRange(tweetSections);
UpdateReplyingTo(status.ReplyingTo);
UpdateFormattedText();
DownloadProfilePicture(status);
}
private void UpdateListOfSections(string splitText, TweetSectionType sectionType, List<TweetSection> listOfSections)
{
switch (sectionType)
{
case TweetSectionType.HashTag:
splitText = "#" + splitText;
break;
case TweetSectionType.UserMention:
splitText = "@" + splitText;
break;
default:
throw new ArgumentException("Invalid section type specified. Must be a HashTag or UserMention");
}
for (var i = 0; i < listOfSections.Count; i++)
{
var tweetSection = listOfSections[i];
if (tweetSection.Type != TweetSectionType.Text)
{
continue;
}
//var split = tweetSection.Text.Split(new[] { splitText }, StringSplitOptions.RemoveEmptyEntries);
var split = Regex.Split(tweetSection.Text, splitText, RegexOptions.IgnoreCase);
listOfSections.RemoveAt(i);
for (var j = 0; j < split.Length; j++)
{
if (j != 0)
{
listOfSections.Insert(i++, new TweetSection(splitText, sectionType));
}
listOfSections.Insert(i++, new TweetSection(split[j], TweetSectionType.Text));
}
}
}
private void UpdateFormattedText()
{
Invoke(() =>
{
var textBlock = new TextBlock();
foreach (var section in Contents)
{
Run run = new Run(section.Text); ;
switch (section.Type)
{
case TweetSectionType.HashTag:
run.Foreground = Brushes.DeepSkyBlue;
break;
case TweetSectionType.UserMention:
run.Foreground = Brushes.DeepSkyBlue;
run.SetValue(Run.FontWeightProperty, FontWeights.Bold);
break;
default:
run.Foreground = Brushes.Black;
break;
}
textBlock.Inlines.Add(run);
}
FormattedText = textBlock;
});
}
private void UpdateReplyingTo(string[] replyingTo)
{
if (replyingTo == null
|| replyingTo.Length == 0)
return;
Invoke(() =>
{
var textBlock = new TextBlock();
textBlock.Inlines.Add(new Run(" · Replying to") { Foreground = Brushes.DarkGray });
foreach (var user in replyingTo)
{
var run = new Run(" " + user);
run.Foreground = Brushes.DeepSkyBlue;
run.SetValue(Run.FontWeightProperty, FontWeights.Bold);
textBlock.Inlines.Add(run);
}
ReplyingTo = textBlock;
});
}
private void DownloadProfilePicture(TwitterViewModel.StatusResponse status)
{
var path = WebHelpers.TwitterProfileImagePath;
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
try
{
var extension = Path.GetExtension(status.User.ProfileImageUrl);
var imagePath = Path.Combine(path, status.User.ScreenName + extension);
using (var client = new WebClient())
{
client.DownloadFile(status.User.ProfileImageUrl, imagePath);
}
ProfileImagePath = imagePath;
}
catch (Exception ex)
{
Log.TraceErr("TweetViewModel: Couldn't download profile picture from {0}. {1}", status.User.ProfileImageUrl, ex.ToString());
}
}
public override string ToString()
{
return string.Concat(Contents.Select(x => x.Text));
}
}
}
| 33.956897 | 140 | 0.535796 | [
"Apache-2.0"
] | chancie86/DigitalSignage | ViewModels/Twitter/TweetViewModel.cs | 7,881 | C# |
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the Apache 2.0 License.
// See the LICENSE file in the project root for more information.
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Steeltoe.Common;
using Steeltoe.Discovery.Eureka.AppInfo;
using Steeltoe.Discovery.Eureka.Test;
using Steeltoe.Discovery.Eureka.Util;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Text.Json;
using Xunit;
namespace Steeltoe.Discovery.Eureka.Transport.Test
{
public class EurekaHttpClientTest : AbstractBaseTest
{
[Fact]
public void Constructor_Throws_IfConfigNull()
{
var ex = Assert.Throws<ArgumentNullException>(() => new EurekaHttpClient((IEurekaClientConfig)null));
Assert.Contains("config", ex.Message);
}
[Fact]
public void Constructor_Throws_IfHeadersNull()
{
IDictionary<string, string> headers = null;
var ex = Assert.Throws<ArgumentNullException>(() => new EurekaHttpClient(new EurekaClientConfig(), headers));
Assert.Contains("headers", ex.Message);
}
[Fact]
public void Constructor_Throws_IfServiceUrlBad()
{
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "foobar\\foobar"
};
var ex = Assert.Throws<UriFormatException>(() => new EurekaHttpClient(config));
Assert.Contains("URI", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task Register_Throws_IfInstanceInfoNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentNullException>(() => client.RegisterAsync(null));
Assert.Contains("info", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task RegisterAsync_ThrowsHttpRequestException_ServerTimeout()
{
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "http://localhost:9999/",
EurekaServerRetryCount = 0
};
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<EurekaTransportException>(() => client.RegisterAsync(new InstanceInfo()));
}
[Fact]
public async System.Threading.Tasks.Task RegisterAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 204;
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var config = new EurekaInstanceConfig();
var info = InstanceInfo.FromInstanceConfig(config);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.RegisterAsync(info);
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.NoContent, resp.StatusCode);
Assert.NotNull(resp.Headers);
}
[Fact]
public async System.Threading.Tasks.Task RegisterAsync_SendsValidPOSTData()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 204;
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var config = new EurekaInstanceConfig()
{
AppName = "foobar"
};
var info = InstanceInfo.FromInstanceConfig(config);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.RegisterAsync(info);
Assert.NotNull(TestConfigServerStartup.LastRequest);
Assert.Equal("POST", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/FOOBAR", TestConfigServerStartup.LastRequest.Path.Value);
// Check JSON payload
var recvJson = JsonSerializer.Deserialize<JsonInstanceInfoRoot>(new StreamReader(TestConfigServerStartup.LastRequest.Body).ReadToEnd());
Assert.NotNull(recvJson);
Assert.NotNull(recvJson.Instance);
// Compare a few random values
var sentJsonObj = info.ToJsonInstance();
Assert.Equal(sentJsonObj.Actiontype, recvJson.Instance.Actiontype);
Assert.Equal(sentJsonObj.AppName, recvJson.Instance.AppName);
Assert.Equal(sentJsonObj.HostName, recvJson.Instance.HostName);
}
[Fact]
public async System.Threading.Tasks.Task SendHeartbeat_Throws_IfAppNameNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.SendHeartBeatAsync(null, "bar", new InstanceInfo(), InstanceStatus.DOWN));
Assert.Contains("appName", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task SendHeartbeat_Throws_IfIdNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.SendHeartBeatAsync("foo", null, new InstanceInfo(), InstanceStatus.DOWN));
Assert.Contains("id", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task SendHeartbeat_Throws_IfInstanceInfoNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentNullException>(() => client.SendHeartBeatAsync("foo", "bar", null, InstanceStatus.DOWN));
Assert.Contains("info", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task SendHeartBeatAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var config = new EurekaInstanceConfig()
{
AppName = "foo",
InstanceId = "id1"
};
var info = InstanceInfo.FromInstanceConfig(config);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.SendHeartBeatAsync("foo", "id1", info, InstanceStatus.UNKNOWN);
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.NotNull(resp.Headers);
Assert.Equal("PUT", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/FOO/id1", TestConfigServerStartup.LastRequest.Path.Value);
var time = DateTimeConversions.ToJavaMillis(new DateTime(info.LastDirtyTimestamp, DateTimeKind.Utc));
Assert.Equal("?status=STARTING&lastDirtyTimestamp=" + time, TestConfigServerStartup.LastRequest.QueryString.Value);
}
[Fact]
public async System.Threading.Tasks.Task GetApplicationsAsync_InvokesServer_ReturnsExpectedApplications()
{
var json = @"
{
""applications"": {
""versions__delta"":""1"",
""apps__hashcode"":""UP_1_"",
""application"":[{
""name"":""FOO"",
""instance"":[{
""instanceId"":""localhost:foo"",
""hostName"":""localhost"",
""app"":""FOO"",
""ipAddr"":""192.168.56.1"",
""status"":""UP"",
""overriddenstatus"":""UNKNOWN"",
""port"":{""$"":8080,""@enabled"":""true""},
""securePort"":{""$"":443,""@enabled"":""false""},
""countryId"":1,
""dataCenterInfo"":{""@class"":""com.netflix.appinfo.InstanceInfo$DefaultDataCenterInfo"",""name"":""MyOwn""},
""leaseInfo"":{""renewalIntervalInSecs"":30,""durationInSecs"":90,""registrationTimestamp"":1457714988223,""lastRenewalTimestamp"":1457716158319,""evictionTimestamp"":0,""serviceUpTimestamp"":1457714988223},
""metadata"":{""@class"":""java.util.Collections$EmptyMap""},
""homePageUrl"":""http://localhost:8080/"",
""statusPageUrl"":""http://localhost:8080/info"",
""healthCheckUrl"":""http://localhost:8080/health"",
""vipAddress"":""foo"",
""isCoordinatingDiscoveryServer"":""false"",
""lastUpdatedTimestamp"":""1457714988223"",
""lastDirtyTimestamp"":""1457714988172"",
""actionType"":""ADDED""
}]
}]
}
}";
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = json;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.GetApplicationsAsync();
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.Equal("GET", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/", TestConfigServerStartup.LastRequest.Path.Value);
Assert.NotNull(resp.Headers);
Assert.NotNull(resp.Response);
Assert.NotNull(resp.Response.ApplicationMap);
Assert.Single(resp.Response.ApplicationMap);
var app = resp.Response.GetRegisteredApplication("foo");
Assert.NotNull(app);
Assert.Equal("FOO", app.Name);
var instances = app.Instances;
Assert.NotNull(instances);
Assert.Equal(1, instances.Count);
foreach (var instance in instances)
{
Assert.Equal("localhost:foo", instance.InstanceId);
Assert.Equal("foo", instance.VipAddress);
Assert.Equal("localhost", instance.HostName);
Assert.Equal("192.168.56.1", instance.IpAddr);
Assert.Equal(InstanceStatus.UP, instance.Status);
}
}
[Fact]
public async System.Threading.Tasks.Task GetVipAsync_Throws_IfVipAddressNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.GetVipAsync(null));
Assert.Contains("vipAddress", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task GetSecureVipAsync_Throws_IfVipAddressNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.GetSecureVipAsync(null));
Assert.Contains("secureVipAddress", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task GetApplicationAsync_Throws_IfAppNameNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.GetApplicationAsync(null));
Assert.Contains("appName", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task GetApplicationAsync_InvokesServer_ReturnsExpectedApplications()
{
var json = @"
{
""application"": {
""name"":""FOO"",
""instance"":[ {
""instanceId"":""localhost:foo"",
""hostName"":""localhost"",
""app"":""FOO"",
""ipAddr"":""192.168.56.1"",
""status"":""UP"",
""overriddenstatus"":""UNKNOWN"",
""port"":{""$"":8080,""@enabled"":""true""},
""securePort"":{""$"":443,""@enabled"":""false""},
""countryId"":1,
""dataCenterInfo"":{""@class"":""com.netflix.appinfo.InstanceInfo$DefaultDataCenterInfo"",""name"":""MyOwn""},
""leaseInfo"":{""renewalIntervalInSecs"":30,""durationInSecs"":90,""registrationTimestamp"":1458152330783,""lastRenewalTimestamp"":1458243422342,""evictionTimestamp"":0,""serviceUpTimestamp"":1458152330783},
""metadata"":{""@class"":""java.util.Collections$EmptyMap""},
""homePageUrl"":""http://localhost:8080/"",
""statusPageUrl"":""http://localhost:8080/info"",
""healthCheckUrl"":""http://localhost:8080/health"",
""vipAddress"":""foo"",
""isCoordinatingDiscoveryServer"":""false"",
""lastUpdatedTimestamp"":""1458152330783"",
""lastDirtyTimestamp"":""1458152330696"",
""actionType"":""ADDED""
}]
}
}";
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = json;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.GetApplicationAsync("foo");
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.Equal("GET", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/foo", TestConfigServerStartup.LastRequest.Path.Value);
Assert.NotNull(resp.Headers);
Assert.NotNull(resp.Response);
Assert.Equal("FOO", resp.Response.Name);
var instances = resp.Response.Instances;
Assert.NotNull(instances);
Assert.Equal(1, instances.Count);
foreach (var instance in instances)
{
Assert.Equal("localhost:foo", instance.InstanceId);
Assert.Equal("foo", instance.VipAddress);
Assert.Equal("localhost", instance.HostName);
Assert.Equal("192.168.56.1", instance.IpAddr);
Assert.Equal(InstanceStatus.UP, instance.Status);
}
Assert.Equal("http://localhost:8888/", client._serviceUrl);
}
[Fact]
public async System.Threading.Tasks.Task GetApplicationAsync__FirstServerFails_InvokesSecondServer_ReturnsExpectedApplications()
{
var json = @"
{
""application"": {
""name"":""FOO"",
""instance"":[{
""instanceId"":""localhost:foo"",
""hostName"":""localhost"",
""app"":""FOO"",
""ipAddr"":""192.168.56.1"",
""status"":""UP"",
""overriddenstatus"":""UNKNOWN"",
""port"":{""$"":8080,""@enabled"":""true""},
""securePort"":{""$"":443,""@enabled"":""false""},
""countryId"":1,
""dataCenterInfo"":{""@class"":""com.netflix.appinfo.InstanceInfo$DefaultDataCenterInfo"",""name"":""MyOwn""},
""leaseInfo"":{""renewalIntervalInSecs"":30,""durationInSecs"":90,""registrationTimestamp"":1458152330783,""lastRenewalTimestamp"":1458243422342,""evictionTimestamp"":0,""serviceUpTimestamp"":1458152330783},
""metadata"":{""@class"":""java.util.Collections$EmptyMap""},
""homePageUrl"":""http://localhost:8080/"",
""statusPageUrl"":""http://localhost:8080/info"",
""healthCheckUrl"":""http://localhost:8080/health"",
""vipAddress"":""foo"",
""isCoordinatingDiscoveryServer"":""false"",
""lastUpdatedTimestamp"":""1458152330783"",
""lastDirtyTimestamp"":""1458152330696"",
""actionType"":""ADDED""
}]
}
}";
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = json;
TestConfigServerStartup.ReturnStatus = 200;
TestConfigServerStartup.Host = "localhost:8888";
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = "https://bad.host:9999/," + uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.GetApplicationAsync("foo");
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.Equal("GET", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/foo", TestConfigServerStartup.LastRequest.Path.Value);
Assert.NotNull(resp.Headers);
Assert.NotNull(resp.Response);
Assert.Equal("FOO", resp.Response.Name);
var instances = resp.Response.Instances;
Assert.NotNull(instances);
Assert.Equal(1, instances.Count);
foreach (var instance in instances)
{
Assert.Equal("localhost:foo", instance.InstanceId);
Assert.Equal("foo", instance.VipAddress);
Assert.Equal("localhost", instance.HostName);
Assert.Equal("192.168.56.1", instance.IpAddr);
Assert.Equal(InstanceStatus.UP, instance.Status);
}
Assert.Equal("http://localhost:8888/", client._serviceUrl);
}
[Fact]
public async System.Threading.Tasks.Task GetInstanceAsync_Throws_IfAppNameNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.GetInstanceAsync(null, "id"));
Assert.Contains("appName", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task GetInstanceAsync_Throws_IfAppNameNotNullAndIDNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.GetInstanceAsync("appName", null));
Assert.Contains("id", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task GetInstanceAsync_Throws_IfIDNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.GetInstanceAsync(null));
Assert.Contains("id", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task GetInstanceAsync_InvokesServer_ReturnsExpectedInstances()
{
var json = @"
{
""instance"": {
""instanceId"":""DESKTOP-GNQ5SUT"",
""app"":""FOOBAR"",
""appGroupName"":null,
""ipAddr"":""192.168.0.147"",
""sid"":""na"",
""port"":{""@enabled"":true,""$"":80},
""securePort"":{""@enabled"":false,""$"":443},
""homePageUrl"":""http://DESKTOP-GNQ5SUT:80/"",
""statusPageUrl"":""http://DESKTOP-GNQ5SUT:80/Status"",
""healthCheckUrl"":""http://DESKTOP-GNQ5SUT:80/healthcheck"",
""secureHealthCheckUrl"":null,
""vipAddress"":""DESKTOP-GNQ5SUT:80"",
""secureVipAddress"":""DESKTOP-GNQ5SUT:443"",
""countryId"":1,
""dataCenterInfo"":{""@class"":""com.netflix.appinfo.InstanceInfo$DefaultDataCenterInfo"",""name"":""MyOwn""},
""hostName"":""DESKTOP-GNQ5SUT"",
""status"":""UP"",
""overriddenstatus"":""UNKNOWN"",
""leaseInfo"":{""renewalIntervalInSecs"":30,""durationInSecs"":90,""registrationTimestamp"":0,""lastRenewalTimestamp"":0,""renewalTimestamp"":0,""evictionTimestamp"":0,""serviceUpTimestamp"":0},
""isCoordinatingDiscoveryServer"":false,
""metadata"":{""@class"":""java.util.Collections$EmptyMap"",""metadata"":null},
""lastUpdatedTimestamp"":1458116137663,
""lastDirtyTimestamp"":1458116137663,
""actionType"":""ADDED"",
""asgName"":null
}
}";
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = json;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.GetInstanceAsync("DESKTOP-GNQ5SUT");
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.Equal("GET", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/instances/DESKTOP-GNQ5SUT", TestConfigServerStartup.LastRequest.Path.Value);
Assert.NotNull(resp.Headers);
Assert.NotNull(resp.Response);
Assert.Equal("DESKTOP-GNQ5SUT", resp.Response.InstanceId);
Assert.Equal("DESKTOP-GNQ5SUT:80", resp.Response.VipAddress);
Assert.Equal("DESKTOP-GNQ5SUT", resp.Response.HostName);
Assert.Equal("192.168.0.147", resp.Response.IpAddr);
Assert.Equal(InstanceStatus.UP, resp.Response.Status);
Assert.Equal("http://localhost:8888/", client._serviceUrl);
}
[Fact]
public async System.Threading.Tasks.Task GetInstanceAsync_FirstServerFails_InvokesSecondServer_ReturnsExpectedInstances()
{
var json = @"
{
""instance"":{
""instanceId"":""DESKTOP-GNQ5SUT"",
""app"":""FOOBAR"",
""appGroupName"":null,
""ipAddr"":""192.168.0.147"",
""sid"":""na"",
""port"":{""@enabled"":true,""$"":80},
""securePort"":{""@enabled"":false,""$"":443},
""homePageUrl"":""http://DESKTOP-GNQ5SUT:80/"",
""statusPageUrl"":""http://DESKTOP-GNQ5SUT:80/Status"",
""healthCheckUrl"":""http://DESKTOP-GNQ5SUT:80/healthcheck"",
""secureHealthCheckUrl"":null,
""vipAddress"":""DESKTOP-GNQ5SUT:80"",
""secureVipAddress"":""DESKTOP-GNQ5SUT:443"",
""countryId"":1,
""dataCenterInfo"":{""@class"":""com.netflix.appinfo.InstanceInfo$DefaultDataCenterInfo"",""name"":""MyOwn""},
""hostName"":""DESKTOP-GNQ5SUT"",
""status"":""UP"",
""overriddenstatus"":""UNKNOWN"",
""leaseInfo"":{""renewalIntervalInSecs"":30,""durationInSecs"":90,""registrationTimestamp"":0,""lastRenewalTimestamp"":0,""renewalTimestamp"":0,""evictionTimestamp"":0,""serviceUpTimestamp"":0},
""isCoordinatingDiscoveryServer"":false,
""metadata"":{""@class"":""java.util.Collections$EmptyMap"",""metadata"":null},
""lastUpdatedTimestamp"":1458116137663,
""lastDirtyTimestamp"":1458116137663,
""actionType"":""ADDED"",
""asgName"":null
}
}";
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = json;
TestConfigServerStartup.ReturnStatus = 200;
TestConfigServerStartup.Host = "localhost:8888";
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = "https://bad.host:9999/," + uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.GetInstanceAsync("DESKTOP-GNQ5SUT");
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.Equal("GET", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/instances/DESKTOP-GNQ5SUT", TestConfigServerStartup.LastRequest.Path.Value);
Assert.NotNull(resp.Headers);
Assert.NotNull(resp.Response);
Assert.Equal("DESKTOP-GNQ5SUT", resp.Response.InstanceId);
Assert.Equal("DESKTOP-GNQ5SUT:80", resp.Response.VipAddress);
Assert.Equal("DESKTOP-GNQ5SUT", resp.Response.HostName);
Assert.Equal("192.168.0.147", resp.Response.IpAddr);
Assert.Equal(InstanceStatus.UP, resp.Response.Status);
Assert.Equal("http://localhost:8888/", client._serviceUrl);
}
[Fact]
public async System.Threading.Tasks.Task CancelAsync_Throws_IfAppNameNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.CancelAsync(null, "id"));
Assert.Contains("appName", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task CancelAsync_Throws_IfAppNameNotNullAndIDNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.CancelAsync("appName", null));
Assert.Contains("id", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task CancelAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.CancelAsync("foo", "bar");
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.NotNull(resp.Headers);
Assert.Equal("DELETE", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/foo/bar", TestConfigServerStartup.LastRequest.Path.Value);
Assert.Equal("http://localhost:8888/", client._serviceUrl);
}
[Fact]
public async System.Threading.Tasks.Task StatusUpdateAsync_Throws_IfAppNameNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.StatusUpdateAsync(null, "id", InstanceStatus.UP, null));
Assert.Contains("appName", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task StatusUpdateAsync_Throws_IfIdNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.StatusUpdateAsync("appName", null, InstanceStatus.UP, null));
Assert.Contains("id", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task StatusUpdateAsync_Throws_IfInstanceInfoNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentNullException>(() => client.StatusUpdateAsync("appName", "bar", InstanceStatus.UP, null));
Assert.Contains("info", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task StatusUpdateAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var now = DateTime.UtcNow.Ticks;
var javaTime = DateTimeConversions.ToJavaMillis(new DateTime(now, DateTimeKind.Utc));
var resp = await client.StatusUpdateAsync("foo", "bar", InstanceStatus.DOWN, new InstanceInfo() { LastDirtyTimestamp = now });
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.NotNull(resp.Headers);
Assert.Equal("PUT", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/foo/bar/status", TestConfigServerStartup.LastRequest.Path.Value);
Assert.Equal("?value=DOWN&lastDirtyTimestamp=" + javaTime, TestConfigServerStartup.LastRequest.QueryString.Value);
Assert.Equal("http://localhost:8888/", client._serviceUrl);
}
[Fact]
public async System.Threading.Tasks.Task DeleteStatusOverrideAsync_Throws_IfAppNameNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.DeleteStatusOverrideAsync(null, "id", null));
Assert.Contains("appName", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task DeleteStatusOverrideAsync_Throws_IfIdNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentException>(() => client.DeleteStatusOverrideAsync("appName", null, null));
Assert.Contains("id", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task DeleteStatusOverrideAsync_Throws_IfInstanceInfoNull()
{
var config = new EurekaClientConfig();
var client = new EurekaHttpClient(config);
var ex = await Assert.ThrowsAsync<ArgumentNullException>(() => client.DeleteStatusOverrideAsync("appName", "bar", null));
Assert.Contains("info", ex.Message);
}
[Fact]
public async System.Threading.Tasks.Task DeleteStatusOverrideAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup<TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var now = DateTime.UtcNow.Ticks;
var javaTime = DateTimeConversions.ToJavaMillis(new DateTime(now, DateTimeKind.Utc));
var resp = await client.DeleteStatusOverrideAsync("foo", "bar", new InstanceInfo() { LastDirtyTimestamp = now });
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.NotNull(resp.Headers);
Assert.Equal("DELETE", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/foo/bar/status", TestConfigServerStartup.LastRequest.Path.Value);
Assert.Equal("?lastDirtyTimestamp=" + javaTime, TestConfigServerStartup.LastRequest.QueryString.Value);
Assert.Equal("http://localhost:8888/", client._serviceUrl);
}
[Fact]
public void MakeServiceUrl_Throws_IfServiceUrlBad()
{
var ex = Assert.Throws<UriFormatException>(() => EurekaHttpClient.MakeServiceUrl("foobar\\foobar"));
Assert.Contains("URI", ex.Message);
}
[Fact]
public void MakeServiceUrl_AppendsSlash_IfMissing()
{
var result = EurekaHttpClient.MakeServiceUrl("http://boo:123");
Assert.Equal("http://boo:123/", result);
}
[Fact]
public void MakeServiceUrl_DoesntAppendSlash_IfPresent()
{
var result = EurekaHttpClient.MakeServiceUrl("http://boo:123/");
Assert.Equal("http://boo:123/", result);
}
[Fact]
public void GetRequestMessage_ReturnsCorrectMesssage_WithAdditionalHeaders()
{
var headers = new Dictionary<string, string>()
{
{ "foo", "bar" }
};
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "http://boo:123/eureka/"
};
var client = new EurekaHttpClient(config, headers);
var result = client.GetRequestMessage(HttpMethod.Post, new Uri("http://boo:123/eureka/"));
Assert.Equal(HttpMethod.Post, result.Method);
Assert.Equal(new Uri("http://boo:123/eureka/"), result.RequestUri);
Assert.True(result.Headers.Contains("foo"));
}
[Fact]
public void GetRequestMessage_No_Auth_When_Creds_Not_In_Url()
{
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "http://boo:123/eureka/"
};
var client = new EurekaHttpClient(config);
var result = client.GetRequestMessage(HttpMethod.Post, new Uri(config.EurekaServerServiceUrls));
Assert.Equal(HttpMethod.Post, result.Method);
Assert.Equal(new Uri("http://boo:123/eureka/"), result.RequestUri);
Assert.False(result.Headers.Contains("Authorization"));
var clientOptions = new EurekaClientOptions { ServiceUrl = "http://boo:123/eureka/" };
var optionsMonitor = new TestOptionMonitorWrapper<EurekaClientOptions>(clientOptions);
client = new EurekaHttpClient(optionsMonitor);
result = client.GetRequestMessage(HttpMethod.Post, new Uri(clientOptions.EurekaServerServiceUrls));
Assert.Equal(HttpMethod.Post, result.Method);
Assert.Equal(new Uri("http://boo:123/eureka/"), result.RequestUri);
Assert.False(result.Headers.Contains("Authorization"));
}
[Fact]
public void GetRequestMessage_Adds_Auth_When_Creds_In_Url()
{
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "http://user:pass@boo:123/eureka/"
};
var client = new EurekaHttpClient(config);
var result = client.GetRequestMessage(HttpMethod.Post, new Uri(config.EurekaServerServiceUrls));
Assert.Equal(HttpMethod.Post, result.Method);
Assert.Equal(new Uri("http://boo:123/eureka/"), result.RequestUri);
Assert.True(result.Headers.Contains("Authorization"));
var clientOptions = new EurekaClientOptions { ServiceUrl = "http://user:pass@boo:123/eureka/" };
var optionsMonitor = new TestOptionMonitorWrapper<EurekaClientOptions>(clientOptions);
client = new EurekaHttpClient(optionsMonitor);
result = client.GetRequestMessage(HttpMethod.Post, new Uri(clientOptions.EurekaServerServiceUrls));
Assert.Equal(HttpMethod.Post, result.Method);
Assert.Equal(new Uri("http://boo:123/eureka/"), result.RequestUri);
Assert.True(result.Headers.Contains("Authorization"));
}
[Fact]
public void GetRequestMessage_Adds_Auth_When_JustPassword_In_Url()
{
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "http://:pass@boo:123/eureka/"
};
var client = new EurekaHttpClient(config);
var result = client.GetRequestMessage(HttpMethod.Post, new Uri(config.EurekaServerServiceUrls));
Assert.Equal(HttpMethod.Post, result.Method);
Assert.Equal(new Uri("http://boo:123/eureka/"), result.RequestUri);
Assert.True(result.Headers.Contains("Authorization"));
var clientOptions = new EurekaClientOptions { ServiceUrl = "http://:pass@boo:123/eureka/" };
var optionsMonitor = new TestOptionMonitorWrapper<EurekaClientOptions>(clientOptions);
client = new EurekaHttpClient(optionsMonitor);
result = client.GetRequestMessage(HttpMethod.Post, new Uri(clientOptions.EurekaServerServiceUrls));
Assert.Equal(HttpMethod.Post, result.Method);
Assert.Equal(new Uri("http://boo:123/eureka/"), result.RequestUri);
Assert.True(result.Headers.Contains("Authorization"));
}
[Fact]
public void GetRequestUri_ReturnsCorrect_WithQueryArguments()
{
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "http://boo:123/eureka/"
};
var client = new EurekaHttpClient(config, new HttpClient());
var queryArgs = new Dictionary<string, string>()
{
{ "foo", "bar" },
{ "bar", "foo" }
};
var result = client.GetRequestUri("http://boo:123/eureka", queryArgs);
Assert.NotNull(result);
Assert.Equal("http://boo:123/eureka?foo=bar&bar=foo", result.ToString());
}
[Fact]
public void GetServiceUrlCandidates_NoFailingUrls_ReturnsExpected()
{
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "http://user:pass@boo:123/eureka/,http://user:pass@foo:123/eureka"
};
var client = new EurekaHttpClient(config);
var result = client.GetServiceUrlCandidates();
Assert.Contains("http://user:pass@boo:123/eureka/", result);
Assert.Contains("http://user:pass@foo:123/eureka/", result);
}
[Fact]
public void GetServiceUrlCandidates_WithFailingUrls_ReturnsExpected()
{
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "https://user:pass@boo:123/eureka/,https://user:pass@foo:123/eureka,https://user:pass@blah:123/eureka,https://user:[email protected]:123/eureka"
};
var client = new EurekaHttpClient(config);
client.AddToFailingServiceUrls("https://user:pass@foo:123/eureka/");
client.AddToFailingServiceUrls("https://user:[email protected]:123/eureka/");
var result = client.GetServiceUrlCandidates();
Assert.Contains("https://user:pass@boo:123/eureka/", result);
Assert.Contains("https://user:pass@blah:123/eureka/", result);
Assert.Equal(2, result.Count);
}
[Fact]
public void GetServiceUrlCandidates_ThresholdHit_ReturnsExpected()
{
var config = new EurekaClientConfig()
{
EurekaServerServiceUrls = "http://user:pass@boo:123/eureka/,http://user:pass@foo:123/eureka"
};
var client = new EurekaHttpClient(config);
client.AddToFailingServiceUrls("http://user:pass@foo:123/eureka/");
var result = client.GetServiceUrlCandidates();
Assert.Contains("http://user:pass@boo:123/eureka/", result);
Assert.Contains("http://user:pass@foo:123/eureka/", result);
}
}
}
| 48.910352 | 239 | 0.579502 | [
"Apache-2.0"
] | ScriptBox99/Steeltoe | src/Discovery/test/Eureka.Test/Transport/EurekaHttpClientTest.cs | 45,831 | C# |
namespace AdventureWork.Infra.CrossCutting.MiddlewareFilterNotification.Exceptions
{
public class NotFoundException : UserFriendlyException
{
public NotFoundException(string message) : base(message)
{
}
}
}
| 24.4 | 83 | 0.709016 | [
"MIT"
] | tmoreirafreitas/AdventureWork | AdventureWork.Infra.CrossCutting.MiddlewareFilterNotification/Exceptions/NotFoundException.cs | 246 | C# |
using Microsoft.AspNetCore.Mvc.RazorPages;
namespace Ext.Net.Examples.Pages.samples.layout.center.basic
{
public class IndexModel : PageModel
{
public void OnGet()
{
}
}
}
| 16.153846 | 60 | 0.638095 | [
"Apache-2.0"
] | extnet/examples.ext.net | src/Pages/samples/layout/center/basic/index.cshtml.cs | 210 | C# |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Notes.UWP")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Notes.UWP")]
[assembly: AssemblyCopyright("Copyright © 2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: ComVisible(false)] | 35.689655 | 84 | 0.738164 | [
"MIT"
] | EkT1oN/MobileDevelopment | Notes/Notes/Notes.UWP/Properties/AssemblyInfo.cs | 1,038 | C# |
// <auto-generated>
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is
// regenerated.
// </auto-generated>
namespace FinnovationLabs.OpenBanking.Library.BankApiModels.UkObRw.V3p1p8.Vrp.Models
{
using Microsoft.Rest;
using Newtonsoft.Json;
using System.Linq;
public partial class OBDomesticVRPConsentResponse
{
/// <summary>
/// Initializes a new instance of the OBDomesticVRPConsentResponse
/// class.
/// </summary>
public OBDomesticVRPConsentResponse()
{
CustomInit();
}
/// <summary>
/// Initializes a new instance of the OBDomesticVRPConsentResponse
/// class.
/// </summary>
public OBDomesticVRPConsentResponse(OBDomesticVRPConsentResponseData data, OBRisk1 risk, Links links, object meta)
{
Data = data;
Risk = risk;
Links = links;
Meta = meta;
CustomInit();
}
/// <summary>
/// An initialization method that performs custom operations like setting defaults
/// </summary>
partial void CustomInit();
/// <summary>
/// </summary>
[JsonProperty(PropertyName = "Data")]
public OBDomesticVRPConsentResponseData Data { get; set; }
/// <summary>
/// </summary>
[JsonProperty(PropertyName = "Risk")]
public OBRisk1 Risk { get; set; }
/// <summary>
/// </summary>
[JsonProperty(PropertyName = "Links")]
public Links Links { get; set; }
/// <summary>
/// </summary>
[JsonProperty(PropertyName = "Meta")]
public object Meta { get; set; }
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (Data == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Data");
}
if (Risk == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Risk");
}
if (Links == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Links");
}
if (Meta == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Meta");
}
if (Data != null)
{
Data.Validate();
}
if (Risk != null)
{
Risk.Validate();
}
if (Links != null)
{
Links.Validate();
}
}
}
}
| 28.693069 | 122 | 0.518288 | [
"MIT"
] | finlabsuk/open-banking-connector | src/OpenBanking.Library.BankApiModels/UkObRw/V3p1p8/Vrp/Models/OBDomesticVRPConsentResponse.cs | 2,898 | C# |
// <copyright file="TelemetrySpanTest.cs" company="OpenTelemetry Authors">
// Copyright The OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// </copyright>
using System;
using System.Diagnostics;
using System.Linq;
using OpenTelemetry.Trace;
using Xunit;
namespace OpenTelemetry.Trace.Tests
{
public class TelemetrySpanTest
{
[Fact]
public void CheckRecordExceptionData()
{
string message = "message";
using Activity activity = new Activity("exception-test");
using TelemetrySpan telemetrySpan = new TelemetrySpan(activity);
telemetrySpan.RecordException(new ArgumentNullException(message, new Exception("new-exception")));
Assert.Single(activity.Events);
var @event = telemetrySpan.Activity.Events.FirstOrDefault(q => q.Name == SemanticConventions.AttributeExceptionEventName);
Assert.Equal(message, @event.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeExceptionMessage).Value);
Assert.Equal(typeof(ArgumentNullException).Name, @event.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeExceptionType).Value);
}
[Fact]
public void CheckRecordExceptionData2()
{
string type = "ArgumentNullException";
string message = "message";
string stack = "stack";
using Activity activity = new Activity("exception-test");
using TelemetrySpan telemetrySpan = new TelemetrySpan(activity);
telemetrySpan.RecordException(type, message, stack);
Assert.Single(activity.Events);
var @event = telemetrySpan.Activity.Events.FirstOrDefault(q => q.Name == SemanticConventions.AttributeExceptionEventName);
Assert.Equal(message, @event.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeExceptionMessage).Value);
Assert.Equal(type, @event.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeExceptionType).Value);
Assert.Equal(stack, @event.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeExceptionStacktrace).Value);
}
[Fact]
public void CheckRecordExceptionEmpty()
{
using Activity activity = new Activity("exception-test");
using TelemetrySpan telemetrySpan = new TelemetrySpan(activity);
telemetrySpan.RecordException(string.Empty, string.Empty, string.Empty);
Assert.Empty(activity.Events);
telemetrySpan.RecordException(null);
Assert.Empty(activity.Events);
}
}
}
| 43.328767 | 153 | 0.687638 | [
"Apache-2.0"
] | humphrieslk/opentelemetry-dotnet | test/OpenTelemetry.Tests/Trace/TelemetrySpanTest.cs | 3,165 | C# |
#region PDFsharp - A .NET library for processing PDF
//
// Authors:
// Stefan Lange (mailto:[email protected])
//
// Copyright (c) 2005-2009 empira Software GmbH, Cologne (Germany)
//
// http://www.pdfsharp.com
// http://sourceforge.net/projects/pdfsharp
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
#endregion
namespace PdfSharp
{
/// <summary>
/// Represents IDs for error and diagnostic messages generated by PDFsharp.
/// </summary>
enum PSMsgID
{
// ----- General Messages ---------------------------------------------------------------------
/// <summary>
/// PSMsgID.
/// </summary>
SampleMessage1,
/// <summary>
/// PSMsgID.
/// </summary>
SampleMessage2,
// ----- XGraphics Messages -------------------------------------------------------------------
// ----- PDF Messages -------------------------------------------------------------------------
/// <summary>
/// PSMsgID.
/// </summary>
NameMustStartWithSlash,
/// <summary>
/// PSMsgID.
/// </summary>
UserOrOwnerPasswordRequired,
// ----- PdfParser Messages -------------------------------------------------------------------
/// <summary>
/// PSMsgID.
/// </summary>
UnexpectedToken,
/// <summary>
/// PSMsgID.
/// </summary>
UnknownEncryption,
}
} | 31.826667 | 99 | 0.595727 | [
"MIT"
] | XpsToPdf/XpsToPdf | XpsToPdf/PdfSharp/enums/PSMsgID.cs | 2,387 | C# |
namespace TLS.DesignLibrary.Calculations.Output
{
class CombinationOutput
{
}
}
| 13.285714 | 48 | 0.698925 | [
"MIT"
] | TLSoftwareUK/Nautilus-DesignLibrary | src/DesignLibrary.Calculations/Output/CombinationOutput.cs | 95 | C# |
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Globalization;
using System.Linq;
using System.Reflection;
using OpenQA.Selenium;
using Tranquire.Selenium.Questions.Converters;
using Tranquire.Selenium.Questions.UIModels;
using Tranquire.Selenium.Questions.UIModels.Converters;
namespace Tranquire.Selenium.Questions
{
/// <summary>
/// Provides questions that maps UI element values to a data model.
/// You can define a UI model by using the attributes <see cref="TargetAttribute"/> and attributes deriving from <see cref="UIStateAttribute"/>
/// </summary>
public static class UIModel
{
internal class UIModelInfo
{
public UIModelInfo(Func<IActor, object> createConverter)
{
CreateConverter = createConverter;
}
public Func<IActor, object> CreateConverter { get; }
}
private static readonly ConcurrentDictionary<Type, UIModelInfo> _containers = new ConcurrentDictionary<Type, UIModelInfo>();
/// <summary>
/// Creates a question for the given model type
/// </summary>
/// <typeparam name="T">The model type that contains properties targeting UI elements</typeparam>
/// <param name="containerTarget">The target that describe the container for the data</param>
/// <returns></returns>
public static UIModel<T> Of<T>(ITarget containerTarget)
{
return Of<T>(containerTarget, $"Get the model of {typeof(T).Name}");
}
/// <summary>
/// Creates a question for the given model type
/// </summary>
/// <typeparam name="T">The model type that contains properties targeting UI elements</typeparam>
/// <param name="containerTarget">The target that describe the container for the data</param>
/// <param name="name">The question name</param>
/// <returns></returns>
public static UIModel<T> Of<T>(ITarget containerTarget, string name)
{
if (containerTarget == null)
{
throw new ArgumentNullException(nameof(containerTarget));
}
var modelInfo = _containers.GetOrAdd(typeof(T), _ => GetUIModelInfo<T>());
return new UIModel<T>(modelInfo, containerTarget, name);
}
private static UIModelInfo GetUIModelInfo<T>()
{
var type = typeof(T);
var setValues = type.GetProperties()
.Where(pi => pi.CanRead && pi.CanWrite)
.Select(pi => (pi, targetAttribute: GetTargetAttribute(pi), uiStateAttribute: GetUIStateAttribute(pi)))
.Where(p => p.targetAttribute != null)
.Select(p => (p.pi, retrieveValue: RetrieveValue(p.pi, p.targetAttribute.CreateTarget, p.targetAttribute.Name, p.uiStateAttribute ?? new TextContentAttribute())))
.Select(f => ExecuteQuestions(f.pi, f.retrieveValue))
.ToArray();
var readonlyProperties = type.GetProperties()
.Where(pi => pi.CanRead && !pi.CanWrite)
.Select(pi => (pi, targetAttribute: GetTargetAttribute(pi), uiStateAttribute: GetUIStateAttribute(pi)))
.Where(p => p.targetAttribute != null)
.Select(p => (p.pi, retrieveValue: RetrieveValue(p.pi, p.targetAttribute.CreateTarget, p.targetAttribute.Name, p.uiStateAttribute ?? new TextContentAttribute())))
.ToDictionary(p => p.pi.Name.ToUpper(), p => p);
var (ctorFound, constructorValues) = type.GetConstructors()
.Select(c => GetPropertiesFromConstructor(c))
.FirstOrDefault(p => p.Item1);
if (!ctorFound)
{
throw new InvalidOperationException("A suitable constructor was not found for the readonly properties\n" +
"Please provide a constructor with the same type and parameter names than the following properties\n" +
string.Join("\n", readonlyProperties.Select(p => "- " + p.Value.pi.Name + ": " + p.Value.pi.PropertyType.Name))
);
}
Func<IActor, ITarget, CultureInfo, IEnumerable<object>> getConstructorValues = (actor, target, culture) =>
constructorValues.Select(c => c(actor, target, culture));
return new UIModelInfo(actor => new ModelConverterBySettingValues<T>(actor, setValues, getConstructorValues));
(bool, Func<IActor, ITarget, CultureInfo, object>[]) GetPropertiesFromConstructor(ConstructorInfo c)
{
var parameters = c.GetParameters();
var properties = parameters
.TakeWhile(pi => readonlyProperties.ContainsKey(pi.Name.ToUpper()))
.Select(pi => readonlyProperties[pi.Name.ToUpper()].retrieveValue)
.ToArray();
if (properties.Length == readonlyProperties.Count)
{
return (true, properties);
}
return (false, Array.Empty<Func<IActor, ITarget, CultureInfo, object>>());
}
}
private static TargetAttribute GetTargetAttribute(PropertyInfo pi)
{
return pi.GetCustomAttributes(typeof(TargetAttribute), true).Cast<TargetAttribute>().SingleOrDefault();
}
private static UIStateAttribute GetUIStateAttribute(PropertyInfo pi)
{
return pi.GetCustomAttributes(typeof(UIStateAttribute), true).Cast<UIStateAttribute>().SingleOrDefault();
}
private sealed class ModelConverterBySettingValues<T> : IConverter<IWebElement, T>
{
private readonly IActor actor;
private readonly IEnumerable<Action<IActor, ITarget, CultureInfo, object>> setValues;
private readonly Func<IActor, ITarget, CultureInfo, IEnumerable<object>> getConstructorValues;
public ModelConverterBySettingValues(IActor actor,
IEnumerable<Action<IActor, ITarget, CultureInfo, object>> setValues,
Func<IActor, ITarget, CultureInfo, IEnumerable<object>> getConstructorValues)
{
this.actor = actor;
this.setValues = setValues;
this.getConstructorValues = getConstructorValues;
}
public T Convert(IWebElement value, CultureInfo culture)
{
var container = Target.The("container").LocatedByWebElement(value);
var constructorValues = getConstructorValues(actor, container, culture);
var model = Activator.CreateInstance(typeof(T), constructorValues.ToArray());
foreach (var setValue in setValues)
{
setValue(actor, container, culture, model);
}
return (T)model;
}
}
private static Action<IActor, ITarget, CultureInfo, object> ExecuteQuestions(PropertyInfo pi, Func<IActor, ITarget, CultureInfo, object> f)
{
return (actor, container, culture, model) => pi.SetValue(model, f(actor, container, culture));
}
private static Func<IActor, ITarget, CultureInfo, object> RetrieveValue(PropertyInfo pi, Func<string, ITarget> createTarget, string name, UIStateAttribute valueAttribute)
{
var target = createTarget(name ?? pi.Name);
return ApplyGetConverter(target, pi.PropertyType, valueAttribute);
}
private static readonly IntegerConverters _integerConverters = new IntegerConverters();
private static readonly BooleanConverters _booleanConverters = new BooleanConverters();
private static readonly StringConverters _textConverters = new StringConverters();
private static readonly DateTimeConverters _dateTimeConverters = new DateTimeConverters();
private static readonly DoubleConverters _doubleConverters = new DoubleConverters();
private static readonly StringArrayConverters _stringArrayConverters = new StringArrayConverters();
private static readonly IntegerArrayConverters _integerArrayConverters = new IntegerArrayConverters();
private static readonly DoubleArrayConverters _doubleArrayConverters = new DoubleArrayConverters();
private static Func<IActor, ITarget, CultureInfo, object> ApplyGetConverter(ITarget target, Type type, UIStateAttribute uiStateAttribute)
{
if (type == typeof(int))
{
return GetFunction(_integerConverters);
}
if (type == typeof(string))
{
return GetFunction(_textConverters);
}
if (type == typeof(bool))
{
return GetFunction(_booleanConverters);
}
if (type == typeof(DateTime))
{
return GetFunction(_dateTimeConverters);
}
if (type == typeof(double))
{
return GetFunction(_doubleConverters);
}
if (type == typeof(ImmutableArray<string>))
{
return GetFunction(_stringArrayConverters);
}
if (type == typeof(ImmutableArray<int>))
{
return GetFunction(_integerArrayConverters);
}
if (type == typeof(ImmutableArray<double>))
{
return GetFunction(_doubleArrayConverters);
}
throw new NotSupportedException($"Type {type} is not supported");
Func<IActor, ITarget, CultureInfo, object> GetFunction<T>(IConverters<T> converters)
{
return (actor, container, culture) =>
{
var relativeTarget = target.RelativeTo(container);
var question = uiStateAttribute.CreateQuestion(relativeTarget, converters, culture);
return actor.AsksFor(question);
};
}
}
}
}
| 49.069767 | 203 | 0.591848 | [
"MIT"
] | gitter-badger/tranquire | src/Tranquire.Selenium/Questions/UIModel.cs | 10,552 | C# |
/*
Problem 9. Exchange Variable Values
• Declare two integer variables a and b and assign them with 5 and 10 and after that exchange their values by using some
programming logic.
• Print the variable values before and after the exchange.
*/
using System;
class ExchangeValues
{
static void Main()
{
int a = 5;
int b = 10;
Console.WriteLine("Variable values before exchange: a = {0}, b = {1}", a, b);
b = b - a; //1 First we calculate the difference between 'a' and 'b' and assign it temporarily to 'b'.
a = a + b; //2 Then, we assign to 'a' the sum of this temporary 'b' with the initial value of 'a'. This sum now equals the initial value of 'b'. Therefore, 'a' acquired the initial value of 'b'.
b = a - b; //3 This line is unnecessary for the particular values stated in the assignment, because 'b' already acquired the initial value of 'a' (10-5=5). But it is mandatory if we want to use different values.
Console.WriteLine("Variable values after exchange: a = {0}, b = {1}", a, b);
}
}
| 48.869565 | 232 | 0.625445 | [
"MIT"
] | mpenchev86/Telerik-Academy | CSharp-Part1/Primitive-Data-Types-And-Variables-Homework/09-ExchangeVariableValues/ExchangeValues.cs | 1,130 | C# |
using System;
namespace ID.Internal
{
internal static class BufferExtensions
{
public static void Fill(this Span<byte> data, uint size)
{
unsafe
{
fixed (byte* ptr = &data.GetPinnableReference())
{
Libsodium.randombytes_buf(ptr, size);
}
}
}
}
} | 21.5 | 64 | 0.470284 | [
"Apache-2.0"
] | danielcrenna/ID | src/ID/Internal/BufferExtensions.cs | 389 | C# |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("04. Cubic Assault")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("04. Cubic Assault")]
[assembly: AssemblyCopyright("Copyright © 2017")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("da12c09c-bcf5-4c98-8984-2bdb1c3bab81")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
| 37.891892 | 84 | 0.745364 | [
"MIT"
] | Filirien/CSharp-Fundamentals | C# Advanced/CSharp Advanced Exam 19 June 2016/04. Cubic Assault/Properties/AssemblyInfo.cs | 1,405 | C# |
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Util;
public class TransformAttachable : MonoBehaviour
{
[Tooltip("Transform that will be adopted by the new parent"), SerializeField]
private Transform _attachable;
[Tooltip("The original parent of the attachable"), SerializeField]
private Transform _originalParentAttachable;
[SerializeField, Disable]
private Transform _newParentAttachable;
void Awake()
{
if (!_attachable)
_attachable = this.transform;
if (!_originalParentAttachable)
_originalParentAttachable = _attachable.transform.parent;
}
public void Attach(Transform parent)
{
this._attachable.SetParent(parent);
_newParentAttachable = parent;
}
public void Detach()
{
this._attachable.SetParent(_originalParentAttachable ? _originalParentAttachable : null);
_newParentAttachable = null;
}
public Transform Attachable
{
get { return _attachable; }
}
} | 26.85 | 97 | 0.695531 | [
"MIT"
] | Luxulicious/Luxulicious.github.io | src/portfolio/BigWeapCombat/Source code/Collision Resolution/TransformAttachable.cs | 1,076 | C# |
namespace CacheFactoryTest.TestDTOs
{
using CacheFactory.Cachers.Base;
using System;
/// <summary>
/// A Cache Item Key to cause exceptions within the test cases.
/// </summary>
public class InvalidCacheItemKey : ACacheItemKey
{
public InvalidCacheItemKey()
{
throw new ArgumentException("Invalid Cache Item Key.");
}
}
}
| 23.058824 | 67 | 0.627551 | [
"MIT"
] | greg1984/CacheFactory | Test/TestDTOs/InvalidCacheItemKey.cs | 394 | C# |
using UnityEngine;
using System.Collections.Generic;
using Pathfinding.Util;
using Pathfinding.Serialization;
namespace Pathfinding {
/// <summary>
/// Exposes internal methods for graphs.
/// This is used to hide methods that should not be used by any user code
/// but still have to be 'public' or 'internal' (which is pretty much the same as 'public'
/// as this library is distributed with source code).
///
/// Hiding the internal methods cleans up the documentation and IntelliSense suggestions.
/// </summary>
public interface IGraphInternals {
string SerializedEditorSettings { get; set; }
void OnDestroy ();
void DestroyAllNodes ();
IEnumerable<Progress> ScanInternal ();
void SerializeExtraInfo (GraphSerializationContext ctx);
void DeserializeExtraInfo (GraphSerializationContext ctx);
void PostDeserialization (GraphSerializationContext ctx);
void DeserializeSettingsCompatibility (GraphSerializationContext ctx);
}
/// <summary>Base class for all graphs</summary>
public abstract class NavGraph : IGraphInternals {
/// <summary>Reference to the AstarPath object in the scene</summary>
public AstarPath active;
/// <summary>
/// Used as an ID of the graph, considered to be unique.
/// Note: This is Pathfinding.Util.Guid not System.Guid. A replacement for System.Guid was coded for better compatibility with iOS
/// </summary>
[JsonMember]
public Guid guid;
/// <summary>Default penalty to apply to all nodes</summary>
[JsonMember]
public uint initialPenalty;
/// <summary>Is the graph open in the editor</summary>
[JsonMember]
public bool open;
/// <summary>Index of the graph, used for identification purposes</summary>
public uint graphIndex;
/// <summary>
/// Name of the graph.
/// Can be set in the unity editor
/// </summary>
[JsonMember]
public string name;
/// <summary>
/// Enable to draw gizmos in the Unity scene view.
/// In the inspector this value corresponds to the state of
/// the 'eye' icon in the top left corner of every graph inspector.
/// </summary>
[JsonMember]
public bool drawGizmos = true;
/// <summary>
/// Used in the editor to check if the info screen is open.
/// Should be inside UNITY_EDITOR only \<see cref="ifs"/> but just in case anyone tries to serialize a NavGraph instance using Unity, I have left it like this as it would otherwise cause a crash when building.
/// Version 3.0.8.1 was released because of this bug only
/// </summary>
[JsonMember]
public bool infoScreenOpen;
/// <summary>Used in the Unity editor to store serialized settings for graph inspectors</summary>
[JsonMember]
string serializedEditorSettings;
/// <summary>True if the graph exists, false if it has been destroyed</summary>
internal bool exists { get { return active != null; } }
/// <summary>
/// Number of nodes in the graph.
/// Note that this is, unless the graph type has overriden it, an O(n) operation.
///
/// This is an O(1) operation for grid graphs and point graphs.
/// For layered grid graphs it is an O(n) operation.
/// </summary>
public virtual int CountNodes () {
int count = 0;
GetNodes(node => count++);
return count;
}
/// <summary>Calls a delegate with all nodes in the graph until the delegate returns false</summary>
public void GetNodes (System.Func<GraphNode, bool> action) {
bool cont = true;
GetNodes(node => {
if (cont) cont &= action(node);
});
}
/// <summary>
/// Calls a delegate with all nodes in the graph.
/// This is the primary way of iterating through all nodes in a graph.
///
/// Do not change the graph structure inside the delegate.
///
/// <code>
/// var gg = AstarPath.active.data.gridGraph;
///
/// gg.GetNodes(node => {
/// // Here is a node
/// Debug.Log("I found a node at position " + (Vector3)node.position);
/// });
/// </code>
///
/// If you want to store all nodes in a list you can do this
///
/// <code>
/// var gg = AstarPath.active.data.gridGraph;
///
/// List<GraphNode> nodes = new List<GraphNode>();
/// gg.GetNodes((System.Action<GraphNode>)nodes.Add);
/// </code>
///
/// See: <see cref="Pathfinding.AstarData.GetNodes"/>
/// </summary>
public abstract void GetNodes (System.Action<GraphNode> action);
/// <summary>
/// A matrix for translating/rotating/scaling the graph.
/// Deprecated: Use the transform field (only available on some graph types) instead
/// </summary>
[System.Obsolete("Use the transform field (only available on some graph types) instead", true)]
public Matrix4x4 matrix = Matrix4x4.identity;
/// <summary>
/// Inverse of matrix.
/// Deprecated: Use the transform field (only available on some graph types) instead
/// </summary>
[System.Obsolete("Use the transform field (only available on some graph types) instead", true)]
public Matrix4x4 inverseMatrix = Matrix4x4.identity;
/// <summary>
/// Use to set both matrix and inverseMatrix at the same time.
/// Deprecated: Use the transform field (only available on some graph types) instead
/// </summary>
[System.Obsolete("Use the transform field (only available on some graph types) instead", true)]
public void SetMatrix (Matrix4x4 m) {
matrix = m;
inverseMatrix = m.inverse;
}
/// <summary>
/// Moves nodes in this graph.
/// Deprecated: Use RelocateNodes(Matrix4x4) instead.
/// To keep the same behavior you can call RelocateNodes(newMatrix * oldMatrix.inverse).
/// </summary>
[System.Obsolete("Use RelocateNodes(Matrix4x4) instead. To keep the same behavior you can call RelocateNodes(newMatrix * oldMatrix.inverse).")]
public void RelocateNodes (Matrix4x4 oldMatrix, Matrix4x4 newMatrix) {
RelocateNodes(newMatrix * oldMatrix.inverse);
}
/// <summary>
/// Moves the nodes in this graph.
/// Multiplies all node positions by deltaMatrix.
///
/// For example if you want to move all your nodes in e.g a point graph 10 units along the X axis from the initial position
/// <code>
/// var graph = AstarPath.data.pointGraph;
/// var m = Matrix4x4.TRS (new Vector3(10,0,0), Quaternion.identity, Vector3.one);
/// graph.RelocateNodes (m);
/// </code>
///
/// Note: For grid graphs, navmesh graphs and recast graphs it is recommended to
/// use their custom overloads of the RelocateNodes method which take parameters
/// for e.g center and nodeSize (and additional parameters) instead since
/// they are both easier to use and are less likely to mess up pathfinding.
///
/// Warning: This method is lossy for PointGraphs, so calling it many times may
/// cause node positions to lose precision. For example if you set the scale
/// to 0 in one call then all nodes will be scaled/moved to the same point and
/// you will not be able to recover their original positions. The same thing
/// happens for other - less extreme - values as well, but to a lesser degree.
/// </summary>
public virtual void RelocateNodes (Matrix4x4 deltaMatrix) {
GetNodes(node => node.position = ((Int3)deltaMatrix.MultiplyPoint((Vector3)node.position)));
}
/// <summary>
/// Returns the nearest node to a position.
/// See: Pathfinding.NNConstraint.None
/// </summary>
/// <param name="position">The position to try to find a close node to</param>
public NNInfoInternal GetNearest (Vector3 position) {
return GetNearest(position, NNConstraint.None);
}
/// <summary>Returns the nearest node to a position using the specified NNConstraint.</summary>
/// <param name="position">The position to try to find a close node to</param>
/// <param name="constraint">Can for example tell the function to try to return a walkable node. If you do not get a good node back, consider calling GetNearestForce.</param>
public NNInfoInternal GetNearest (Vector3 position, NNConstraint constraint) {
return GetNearest(position, constraint, null);
}
/// <summary>Returns the nearest node to a position using the specified NNConstraint.</summary>
/// <param name="position">The position to try to find a close node to</param>
/// <param name="hint">Can be passed to enable some graph generators to find the nearest node faster.</param>
/// <param name="constraint">Can for example tell the function to try to return a walkable node. If you do not get a good node back, consider calling GetNearestForce.</param>
public virtual NNInfoInternal GetNearest (Vector3 position, NNConstraint constraint, GraphNode hint) {
// This is a default implementation and it is pretty slow
// Graphs usually override this to provide faster and more specialised implementations
float maxDistSqr = constraint == null || constraint.constrainDistance ? AstarPath.active.maxNearestNodeDistanceSqr : float.PositiveInfinity;
float minDist = float.PositiveInfinity;
GraphNode minNode = null;
float minConstDist = float.PositiveInfinity;
GraphNode minConstNode = null;
// Loop through all nodes and find the closest suitable node
GetNodes(node => {
float dist = (position-(Vector3)node.position).sqrMagnitude;
if (dist < minDist) {
minDist = dist;
minNode = node;
}
if (dist < minConstDist && dist < maxDistSqr && (constraint == null || constraint.Suitable(node))) {
minConstDist = dist;
minConstNode = node;
}
});
var nnInfo = new NNInfoInternal(minNode);
nnInfo.constrainedNode = minConstNode;
if (minConstNode != null) {
nnInfo.constClampedPosition = (Vector3)minConstNode.position;
} else if (minNode != null) {
nnInfo.constrainedNode = minNode;
nnInfo.constClampedPosition = (Vector3)minNode.position;
}
return nnInfo;
}
/// <summary>
/// Returns the nearest node to a position using the specified \link Pathfinding.NNConstraint constraint \endlink.
/// Returns: an NNInfo. This method will only return an empty NNInfo if there are no nodes which comply with the specified constraint.
/// </summary>
public virtual NNInfoInternal GetNearestForce (Vector3 position, NNConstraint constraint) {
return GetNearest(position, constraint);
}
/// <summary>
/// Function for cleaning up references.
/// This will be called on the same time as OnDisable on the gameObject which the AstarPath script is attached to (remember, not in the editor).
/// Use for any cleanup code such as cleaning up static variables which otherwise might prevent resources from being collected.
/// Use by creating a function overriding this one in a graph class, but always call base.OnDestroy () in that function.
/// All nodes should be destroyed in this function otherwise a memory leak will arise.
/// </summary>
protected virtual void OnDestroy () {
DestroyAllNodes();
}
/// <summary>
/// Destroys all nodes in the graph.
/// Warning: This is an internal method. Unless you have a very good reason, you should probably not call it.
/// </summary>
protected virtual void DestroyAllNodes () {
GetNodes(node => node.Destroy());
}
/// <summary>
/// Scan the graph.
/// Deprecated: Use AstarPath.Scan() instead
/// </summary>
[System.Obsolete("Use AstarPath.Scan instead")]
public void ScanGraph () {
Scan();
}
/// <summary>
/// Scan the graph.
///
/// Consider using AstarPath.Scan() instead since this function only scans this graph and if you are using multiple graphs
/// with connections between them, then it is better to scan all graphs at once.
/// </summary>
public void Scan () {
active.Scan(this);
}
/// <summary>
/// Internal method to scan the graph.
/// Called from AstarPath.ScanAsync.
/// Override this function to implement custom scanning logic.
/// Progress objects can be yielded to show progress info in the editor and to split up processing
/// over several frames when using async scanning.
/// </summary>
protected abstract IEnumerable<Progress> ScanInternal ();
/// <summary>
/// Serializes graph type specific node data.
/// This function can be overriden to serialize extra node information (or graph information for that matter)
/// which cannot be serialized using the standard serialization.
/// Serialize the data in any way you want and return a byte array.
/// When loading, the exact same byte array will be passed to the DeserializeExtraInfo function.\n
/// These functions will only be called if node serialization is enabled.\n
/// </summary>
protected virtual void SerializeExtraInfo (GraphSerializationContext ctx) {
}
/// <summary>
/// Deserializes graph type specific node data.
/// See: SerializeExtraInfo
/// </summary>
protected virtual void DeserializeExtraInfo (GraphSerializationContext ctx) {
}
/// <summary>
/// Called after all deserialization has been done for all graphs.
/// Can be used to set up more graph data which is not serialized
/// </summary>
protected virtual void PostDeserialization (GraphSerializationContext ctx) {
}
/// <summary>
/// An old format for serializing settings.
/// Deprecated: This is deprecated now, but the deserialization code is kept to
/// avoid loosing data when upgrading from older versions.
/// </summary>
protected virtual void DeserializeSettingsCompatibility (GraphSerializationContext ctx) {
guid = new Guid(ctx.reader.ReadBytes(16));
initialPenalty = ctx.reader.ReadUInt32();
open = ctx.reader.ReadBoolean();
name = ctx.reader.ReadString();
drawGizmos = ctx.reader.ReadBoolean();
infoScreenOpen = ctx.reader.ReadBoolean();
}
/// <summary>Draw gizmos for the graph</summary>
public virtual void OnDrawGizmos (RetainedGizmos gizmos, bool drawNodes) {
if (!drawNodes) {
return;
}
// This is a relatively slow default implementation.
// subclasses of the base graph class may override
// this method to draw gizmos in a more optimized way
var hasher = new RetainedGizmos.Hasher(active);
GetNodes(node => hasher.HashNode(node));
// Update the gizmo mesh if necessary
if (!gizmos.Draw(hasher)) {
using (var helper = gizmos.GetGizmoHelper(active, hasher)) {
GetNodes((System.Action<GraphNode>)helper.DrawConnections);
}
}
if (active.showUnwalkableNodes) DrawUnwalkableNodes(active.unwalkableNodeDebugSize);
}
protected void DrawUnwalkableNodes (float size) {
Gizmos.color = AstarColor.UnwalkableNode;
GetNodes(node => {
if (!node.Walkable) Gizmos.DrawCube((Vector3)node.position, Vector3.one*size);
});
}
#region IGraphInternals implementation
string IGraphInternals.SerializedEditorSettings { get { return serializedEditorSettings; } set { serializedEditorSettings = value; } }
void IGraphInternals.OnDestroy () { OnDestroy(); }
void IGraphInternals.DestroyAllNodes () { DestroyAllNodes(); }
IEnumerable<Progress> IGraphInternals.ScanInternal () { return ScanInternal(); }
void IGraphInternals.SerializeExtraInfo (GraphSerializationContext ctx) { SerializeExtraInfo(ctx); }
void IGraphInternals.DeserializeExtraInfo (GraphSerializationContext ctx) { DeserializeExtraInfo(ctx); }
void IGraphInternals.PostDeserialization (GraphSerializationContext ctx) { PostDeserialization(ctx); }
void IGraphInternals.DeserializeSettingsCompatibility (GraphSerializationContext ctx) { DeserializeSettingsCompatibility(ctx); }
#endregion
}
/// <summary>
/// Handles collision checking for graphs.
/// Mostly used by grid based graphs
/// </summary>
[System.Serializable]
public class GraphCollision {
/// <summary>
/// Collision shape to use.
/// See: <see cref="Pathfinding.ColliderType"/>
/// </summary>
public ColliderType type = ColliderType.Capsule;
/// <summary>
/// Diameter of capsule or sphere when checking for collision.
/// When checking for collisions the system will check if any colliders
/// overlap a specific shape at the node's position. The shape is determined
/// by the <see cref="type"/> field.
///
/// A diameter of 1 means that the shape has a diameter equal to the node's width,
/// or in other words it is equal to \link Pathfinding.GridGraph.nodeSize nodeSize \endlink.
///
/// If <see cref="type"/> is set to Ray, this does not affect anything.
///
/// [Open online documentation to see images]
/// </summary>
public float diameter = 1F;
/// <summary>
/// Height of capsule or length of ray when checking for collision.
/// If <see cref="type"/> is set to Sphere, this does not affect anything.
///
/// [Open online documentation to see images]
/// </summary>
public float height = 2F;
/// <summary>
/// Height above the ground that collision checks should be done.
/// For example, if the ground was found at y=0, collisionOffset = 2
/// type = Capsule and height = 3 then the physics system
/// will be queried to see if there are any colliders in a capsule
/// for which the bottom sphere that is made up of is centered at y=2
/// and the top sphere has its center at y=2+3=5.
///
/// If type = Sphere then the sphere's center would be at y=2 in this case.
/// </summary>
public float collisionOffset;
/// <summary>
/// Direction of the ray when checking for collision.
/// If <see cref="type"/> is not Ray, this does not affect anything
/// </summary>
public RayDirection rayDirection = RayDirection.Both;
/// <summary>Layers to be treated as obstacles.</summary>
public LayerMask mask;
/// <summary>Layers to be included in the height check.</summary>
public LayerMask heightMask = -1;
/// <summary>
/// The height to check from when checking height ('ray length' in the inspector).
///
/// As the image below visualizes, different ray lengths can make the ray hit different things.
/// The distance is measured up from the graph plane.
///
/// [Open online documentation to see images]
/// </summary>
public float fromHeight = 100;
/// <summary>
/// Toggles thick raycast.
/// See: https://docs.unity3d.com/ScriptReference/Physics.SphereCast.html
/// </summary>
public bool thickRaycast;
/// <summary>
/// Diameter of the thick raycast in nodes.
/// 1 equals \link Pathfinding.GridGraph.nodeSize nodeSize \endlink
/// </summary>
public float thickRaycastDiameter = 1;
/// <summary>Make nodes unwalkable when no ground was found with the height raycast. If height raycast is turned off, this doesn't affect anything.</summary>
public bool unwalkableWhenNoGround = true;
/// <summary>
/// Use Unity 2D Physics API.
/// See: http://docs.unity3d.com/ScriptReference/Physics2D.html
/// </summary>
public bool use2D;
/// <summary>Toggle collision check</summary>
public bool collisionCheck = true;
/// <summary>Toggle height check. If false, the grid will be flat</summary>
public bool heightCheck = true;
/// <summary>
/// Direction to use as UP.
/// See: Initialize
/// </summary>
public Vector3 up;
/// <summary>
/// <see cref="up"/> * <see cref="height"/>.
/// See: Initialize
/// </summary>
private Vector3 upheight;
/// <summary>
/// <see cref="diameter"/> * scale * 0.5.
/// Where scale usually is \link Pathfinding.GridGraph.nodeSize nodeSize \endlink
/// See: Initialize
/// </summary>
private float finalRadius;
/// <summary>
/// <see cref="thickRaycastDiameter"/> * scale * 0.5.
/// Where scale usually is \link Pathfinding.GridGraph.nodeSize nodeSize \endlink See: Initialize
/// </summary>
private float finalRaycastRadius;
/// <summary>Offset to apply after each raycast to make sure we don't hit the same point again in CheckHeightAll</summary>
public const float RaycastErrorMargin = 0.005F;
/// <summary>
/// Sets up several variables using the specified matrix and scale.
/// See: GraphCollision.up
/// See: GraphCollision.upheight
/// See: GraphCollision.finalRadius
/// See: GraphCollision.finalRaycastRadius
/// </summary>
public void Initialize (GraphTransform transform, float scale) {
up = (transform.Transform(Vector3.up) - transform.Transform(Vector3.zero)).normalized;
upheight = up*height;
finalRadius = diameter*scale*0.5F;
finalRaycastRadius = thickRaycastDiameter*scale*0.5F;
}
/// <summary>
/// Returns if the position is obstructed.
/// If <see cref="collisionCheck"/> is false, this will always return true.\n
/// </summary>
public bool Check (Vector3 position) {
if (!collisionCheck) {
return true;
}
if (use2D) {
switch (type) {
case ColliderType.Capsule:
case ColliderType.Sphere:
return Physics2D.OverlapCircle(position, finalRadius, mask) == null;
default:
return Physics2D.OverlapPoint(position, mask) == null;
}
}
position += up*collisionOffset;
switch (type) {
case ColliderType.Capsule:
return !Physics.CheckCapsule(position, position+upheight, finalRadius, mask, QueryTriggerInteraction.Ignore);
case ColliderType.Sphere:
return !Physics.CheckSphere(position, finalRadius, mask, QueryTriggerInteraction.Ignore);
default:
switch (rayDirection) {
case RayDirection.Both:
return !Physics.Raycast(position, up, height, mask, QueryTriggerInteraction.Ignore) && !Physics.Raycast(position+upheight, -up, height, mask, QueryTriggerInteraction.Ignore);
case RayDirection.Up:
return !Physics.Raycast(position, up, height, mask, QueryTriggerInteraction.Ignore);
default:
return !Physics.Raycast(position+upheight, -up, height, mask, QueryTriggerInteraction.Ignore);
}
}
}
/// <summary>
/// Returns the position with the correct height.
/// If <see cref="heightCheck"/> is false, this will return position.
/// </summary>
public Vector3 CheckHeight (Vector3 position) {
RaycastHit hit;
bool walkable;
return CheckHeight(position, out hit, out walkable);
}
/// <summary>
/// Returns the position with the correct height.
/// If <see cref="heightCheck"/> is false, this will return position.\n
/// walkable will be set to false if nothing was hit.
/// The ray will check a tiny bit further than to the grids base to avoid floating point errors when the ground is exactly at the base of the grid
/// </summary>
public Vector3 CheckHeight (Vector3 position, out RaycastHit hit, out bool walkable) {
walkable = true;
if (!heightCheck || use2D) {
hit = new RaycastHit();
return position;
}
if (thickRaycast) {
var ray = new Ray(position+up*fromHeight, -up);
if (Physics.SphereCast(ray, finalRaycastRadius, out hit, fromHeight+0.005F, heightMask, QueryTriggerInteraction.Ignore)) {
return VectorMath.ClosestPointOnLine(ray.origin, ray.origin+ray.direction, hit.point);
}
walkable &= !unwalkableWhenNoGround;
} else {
// Cast a ray from above downwards to try to find the ground
if (Physics.Raycast(position+up*fromHeight, -up, out hit, fromHeight+0.005F, heightMask, QueryTriggerInteraction.Ignore)) {
return hit.point;
}
walkable &= !unwalkableWhenNoGround;
}
return position;
}
/// <summary>Internal buffer used by <see cref="CheckHeightAll"/></summary>
RaycastHit[] hitBuffer = new RaycastHit[8];
/// <summary>
/// Returns all hits when checking height for position.
/// Warning: Does not work well with thick raycast, will only return an object a single time
///
/// Warning: The returned array is ephermal. It will be invalidated when this method is called again.
/// If you need persistent results you should copy it.
///
/// The returned array may be larger than the actual number of hits, the numHits out parameter indicates how many hits there actually were.
/// </summary>
public RaycastHit[] CheckHeightAll (Vector3 position, out int numHits) {
if (!heightCheck || use2D) {
hitBuffer[0] = new RaycastHit {
point = position,
distance = 0,
};
numHits = 1;
return hitBuffer;
}
// Cast a ray from above downwards to try to find the ground
var result = Physics.RaycastAll(position+up*fromHeight, -up, fromHeight+0.005F, heightMask, QueryTriggerInteraction.Ignore);
numHits = result.Length;
return result;
}
public void DeserializeSettingsCompatibility (GraphSerializationContext ctx) {
type = (ColliderType)ctx.reader.ReadInt32();
diameter = ctx.reader.ReadSingle();
height = ctx.reader.ReadSingle();
collisionOffset = ctx.reader.ReadSingle();
rayDirection = (RayDirection)ctx.reader.ReadInt32();
mask = (LayerMask)ctx.reader.ReadInt32();
heightMask = (LayerMask)ctx.reader.ReadInt32();
fromHeight = ctx.reader.ReadSingle();
thickRaycast = ctx.reader.ReadBoolean();
thickRaycastDiameter = ctx.reader.ReadSingle();
unwalkableWhenNoGround = ctx.reader.ReadBoolean();
use2D = ctx.reader.ReadBoolean();
collisionCheck = ctx.reader.ReadBoolean();
heightCheck = ctx.reader.ReadBoolean();
}
}
/// <summary>
/// Determines collision check shape.
/// See: <see cref="Pathfinding.GraphCollision"/>
/// </summary>
public enum ColliderType {
/// <summary>Uses a Sphere, Physics.CheckSphere. In 2D this is a circle instead.</summary>
Sphere,
/// <summary>Uses a Capsule, Physics.CheckCapsule. This will behave identically to the Sphere mode in 2D.</summary>
Capsule,
/// <summary>Uses a Ray, Physics.Linecast. In 2D this is a single point instead.</summary>
Ray
}
/// <summary>Determines collision check ray direction</summary>
public enum RayDirection {
Up, /// <summary>< Casts the ray from the bottom upwards</summary>
Down, /// <summary>< Casts the ray from the top downwards</summary>
Both /// <summary>< Casts two rays in both directions</summary>
}
}
| 38.013314 | 211 | 0.704635 | [
"Unlicense"
] | Ehwhat/BetaArcadeGame | Assets/Plugins/AstarPathfindingProject/Generators/Base.cs | 25,697 | C# |
//using System.Collections.Generic;
//using System.Threading.Tasks;
//namespace NextGenSoftware.OASIS.API.ONODE.WebAPI
//{
// public interface ISCMSService
// {
// Task<IEnumerable<Sequence>> GetAllSequences();
// }
//}
| 30.636364 | 99 | 0.480712 | [
"CC0-1.0"
] | HirenBodhi/Our-World-OASIS-API-HoloNET-HoloUnity-And-.NET-HDK | NextGenSoftware.OASIS.API.ONODE.WebAPI/Interfaces/ISCMSService.cs | 339 | C# |
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
namespace Microsoft.Identity.Json.Utilities
{
internal readonly struct StructMultiKey<T1, T2> : IEquatable<StructMultiKey<T1, T2>>
{
public readonly T1 Value1;
public readonly T2 Value2;
public StructMultiKey(T1 v1, T2 v2)
{
Value1 = v1;
Value2 = v2;
}
public override int GetHashCode()
{
return (Value1?.GetHashCode() ?? 0) ^ (Value2?.GetHashCode() ?? 0);
}
public override bool Equals(object obj)
{
if (!(obj is StructMultiKey<T1, T2> key))
{
return false;
}
return Equals(key);
}
public bool Equals(StructMultiKey<T1, T2> other)
{
return (Equals(Value1, other.Value1) && Equals(Value2, other.Value2));
}
}
} | 33.098361 | 88 | 0.659237 | [
"MIT"
] | vboctor/azure-activedirectory-library-for-dotnet | msal/src/Microsoft.Identity.Client/json/Utilities/StructMultiKey.cs | 2,021 | C# |
// Copyright (C) WIFIPLUG. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Text;
namespace WifiPlug.Api.Entities
{
/// <summary>
/// Represents an item in a group.
/// </summary>
public class GroupItemEntity
{
/// <summary>
/// Gets or sets the UUID.
/// </summary>
[JsonProperty(PropertyName = "uuid")]
public Guid UUID { get; set; }
/// <summary>
/// Gets or sets the device.
/// </summary>
[JsonProperty(PropertyName = "device")]
public DeviceEntity Device { get; set; }
/// <summary>
/// Gets or sets the target service.
/// </summary>
[JsonProperty(PropertyName = "service")]
public DeviceServiceEntity Service { get; set; }
/// <summary>
/// Gets or sets the target characteristic.
/// </summary>
[JsonProperty(PropertyName = "characteristic")]
public DeviceServiceCharacteristicEntity Characteristic { get; set; }
}
}
| 28.780488 | 107 | 0.602542 | [
"Apache-2.0"
] | wifiplug/api-client-net | src/WifiPlug.Api/Entities/GroupItemEntity.cs | 1,182 | C# |
namespace XMap
{
using System;
using System.Linq.Expressions;
using System.Reflection;
using System.Xml.Linq;
class CustomElementConverterActionGenerator<TItem, TProperty>
{
private readonly Expression<Func<XElement, TProperty>> _converter;
private readonly ParameterExpression _elementParam;
private readonly ParameterExpression _itemParam;
private readonly MemberExpression _itemProperty;
public CustomElementConverterActionGenerator(PropertyInfo propertyInfo, Expression<Func<XElement, TProperty>> converter)
{
_converter = converter;
_elementParam = Expression.Parameter(typeof(XElement));
_itemParam = Expression.Parameter(typeof(TItem));
_itemProperty = Expression.Property(_itemParam, propertyInfo);
}
public Action<XElement, TItem> Generate()
{
return Compile(Expression.Assign(_itemProperty, Expression.Invoke(_converter, _elementParam)));
}
protected Action<XElement, TItem> Compile(Expression body)
{
return Expression.Lambda<Action<XElement, TItem>>(body, _elementParam, _itemParam).Compile();
}
}
} | 37.939394 | 129 | 0.670128 | [
"MIT"
] | markrendle/XMap | XMap/CustomElementConverterActionGenerator.cs | 1,254 | C# |
/****
* PMSM calculation - automate PMSM design process
* Created 2016 by Ngo Phuong Le
* https://github.com/lehn85/pmsm_calculation
* All files are provided under the MIT license.
****/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Femm;
using MathNet.Numerics.LinearAlgebra;
using MathNet.Numerics.LinearAlgebra.Double;
using System.Diagnostics;
using System.Reflection;
using System.IO;
using log4net;
namespace calc_from_geometryOfMotor
{
public class FEMM
{
private static readonly ILog log = LogManager.GetLogger("FEMM");
// Get the active X call
private static FEMM defaultFemm = null;
public static FEMM DefaultFEMM
{
get
{
if (defaultFemm == null)
{
defaultFemm = new FEMM();
}
return defaultFemm;
}
private set
{
defaultFemm = value;
}
}
private IActiveFEMM femm;
public FEMM()
{
//femm = new ActiveFEMMClass(); //before NET4.0
femm = new ActiveFEMM();//NET4.0+
}
/// <summary>
/// Kill all femm
/// </summary>
public static void CloseFemm()
{
quit();
DefaultFEMM = null;
}
public String callFemm(String cmd, params object[] args)
{
return femm.call2femm(String.Format(cmd, args));
}
#region common commands
public void clearconsole()
{
callFemm("clearconsole()");
}
public void hideconsole()
{
callFemm("hideconsole()");
}
public void showconsole()
{
callFemm("showconsole()");
}
/// <summary>
/// Open new document
/// </summary>
/// <param name="doctype">Type of document to open</param>
public void newdocument(DocumentType doctype)
{
callFemm("newdocument({0})", doctype.GetHashCode());
}
public enum DocumentType
{
Magnetic = 0,
Electrostatic = 1,
Heatflow = 2,
Currentflow = 3
}
/// <summary>
/// Quit because the command quit seems useless
/// </summary>
public static void quit()
{
Process[] p = Process.GetProcessesByName("femm");
foreach (Process pc in p)
{
try
{
pc.Kill();
}
catch (Exception ex)
{
log.Error("Error: " + ex.Message);
}
}
}
public void showpointprops()
{
callFemm("showpointprops()");
}
public void open(String filename)
{
callFemm("open(\"{0}\")", filename.Replace('\\', '/'));
}
#endregion
#region FEMM magnetic editing
#region Object add/remove commands
//add a new node at x,y
public void mi_addnode(double x, double y)
{
callFemm("mi_addnode({0},{1})", x, y);
}
// add a new line segment from node cloest to x1,y1 to x2,y2
public void mi_addsegment(double x1, double y1, double x2, double y2)
{
callFemm("mi_addsegment({0},{1},{2},{3})", x1, y1, x2, y2);
}
//add a new block label at x,y
public void mi_addblocklabel(double x, double y)
{
callFemm("mi_addblocklabel({0},{1})", x, y);
}
//add a new arc segment from the nearest node to x1,y1 to x2,y2 with angle divided into maxseg
public void mi_addarc(double x1, double y1, double x2, double y2, double angle, double maxseg)
{
callFemm("mi_addarc({0},{1},{2},{3},{4},{5})", x1, y1, x2, y2, angle, maxseg);
}
// delete all selected objects
public void mi_deleteselected()
{
callFemm("mi_deleteselected()");
}
// delete all selected objects
public void mi_deleteselectednodes()
{
callFemm("mi_deleteselectednodes()");
}
// delete all selected objects
public void mi_deleteselectedlabels()
{
callFemm("mi_deleteselectedlabels()");
}
// delete all selected objects
public void mi_deleteselectedsegments()
{
callFemm("mi_deleteselectedsegments()");
}
// delete all selected objects
public void mi_deleteselectedarcsegments()
{
callFemm("mi_deleteselectedarcsegments()");
}
#endregion
#region Geometry selection commands
//de-select objects
public void mi_clearselected()
{
callFemm("mi_clearselected()");
}
//select line segment near x,y
public void mi_selectsegment(double x, double y)
{
callFemm("mi_selectsegment({0},{1})", x, y);
}
//select node near x,y
public void mi_selectnode(double x, double y)
{
callFemm("mi_selectnode({0},{1})", x, y);
}
//select label near x,y
public void mi_selectlabel(double x, double y)
{
callFemm("mi_selectlabel({0},{1})", x, y);
}
//select arc segment near x,y
public void mi_selectarcsegment(double x, double y)
{
callFemm("mi_selectarcsegment({0},{1})", x, y);
}
//select group n-th
public void mi_selectgroup(int n)
{
callFemm("mi_selectgroup({0})", n);
}
#endregion
#region Object labeling commands
//set the selected nodes to have the nodal property mi_"propname" and group number n
public void mi_setnodeprop(String propname, int n)
{
callFemm("mi_setnodeprop(\"{0}\",{1})", propname, n);
}
/** Set selected block to have the following properties:
* - Block: "blockname". (block type)
– automesh: 0 = mesher defers to mesh size constraint defined in meshsize, 1 = mesher
automatically chooses the mesh density.
– meshsize: size constraint on the mesh in the block marked by this label.
– Block is a member of the circuit named "incircuit"
– The magnetization is directed along an angle in measured in degrees denoted by the
parameter magdirection. Alternatively, magdirection can be a string containing a
formula that prescribes the magnetization direction as a function of element position.
In this formula theta and R denotes the angle in degrees of a line connecting the center
each element with the origin and the length of this line, respectively; x and y denote
the x- and y-position of the center of the each element. For axisymmetric problems, r
and z should be used in place of x and y.
– A member of group number group
– The number of turns associated with this label is denoted by turns
* */
public void mi_setblockprop(String blockname, bool automesh, double meshsize, String incircuit, double magnetdirection, int group, int turns)
{
callFemm("mi_setblockprop(\"{0}\",{1},{2},\"{3}\",{4},{5},{6})",
blockname, automesh ? 1 : 0, meshsize, incircuit, magnetdirection, group, turns);
}
/// <summary>
/// Set the select segments the properties
/// </summary>
/// <param name="propname">Boundary property "propname"</param>
/// <param name="elementsize">Local element size along segment no greater than elementsize</param>
/// <param name="automesh">automesh: 0 = mesher defers to the element constraint defined by elementsize, 1 =
/// mesher automatically chooses mesh size along the selected segments</param>
/// <param name="hide">hide: 0 = not hidden in post-processor, 1 == hidden in post processor</param>
/// <param name="group">A member of group number group</param>
public void mi_setsegmentprop(String propname, double elementsize, bool automesh, bool hide, int group)
{
callFemm("mi_setsegmentprop(\"{0}\",{1},{2},{3},{4})",
propname, elementsize, automesh ? 1 : 0, hide ? 1 : 0, group);
}
/**
* mi setarcsegmentprop(maxsegdeg, "propname", hide, group) Set the selected arc
segments to:
– Meshed with elements that span at most maxsegdeg degrees per element
– Boundary property "propname"
– hide: 0 = not hidden in post-processor, 1 == hidden in post processor
– A member of group number group
* */
public void mi_setarcsegmentprop(double maxsegdeg, String propname, bool hide, int group)
{
callFemm("mi_setarcsegmentprop({0},\"{1}\",{2},{3})",
maxsegdeg, propname, hide ? 1 : 0, group);
}
#endregion
#region Problem commands
/// <summary>
/// Changes the problem definition.
/// </summary>
/// <param name="frequency">Set frequency to the desired frequency in Hertz. </param>
/// <param name="units">Valid "units" entries are "inches", "millimeters", "centimeters", "mils", "meters, and "micrometers".</param>
/// <param name="problemtype">Set the parameter problemtype to "planar" for a 2-D planar problem, or to "axi" for an
/// axisymmetric problem.</param>
/// <param name="precision">The precision parameter dictates the precision required by the
/// solver. For example, entering 1E-8 requires the RMS of the residual to be less than 1e−8.</param>
/// <param name="depth">representing the depth of the problem in the into-the-page direction for
/// 2-D planar problems, can also also be specified</param>
/// <param name="minangle">minimum angle constraint sent to the mesh generator</param>
/// <param name="acsolver">"Succ. Approx" or "Newton"</param>
public void mi_probdef(double frequency, UnitsType units, ProblemType problemtype, double precision, double depth, double minangle, ACSolverType acsolver = ACSolverType.Succ_Approx)
{
callFemm("mi_probdef({0},\"{1}\",\"{2}\",{3},{4},{5},\"{6}\")",
frequency, units, problemtype, precision, depth, minangle, acsolver.GetHashCode());
}
public enum UnitsType
{
inches, millimeters, centimeters, mils, meters, micrometers
}
public enum ProblemType
{
planar, axi
}
public enum ACSolverType
{
Succ_Approx = 0,
Newton = 1
}
/**
* mi analyze(flag) runs fkern to solve the problem. The flag parameter controls whether
the fkern window is visible or minimized. For a visible window, either specify no value for
flag or specify 0. For a minimized window, flag should be set to 1.
* */
public void mi_analyze(bool minimizeWindow = false)
{
callFemm("mi_analyze({0})", minimizeWindow ? 1 : 0);
}
/**
* mi loadsolution() loads and displays the solution corresponding to the current geometry.
*/
public void mi_loadsolution()
{
callFemm("mi_loadsolution()");
}
/**
* mi saveas("filename") saves the file with name "filename". Note if you use a path you
must use two backslashes e.g. "c:\\temp\\myfemmfile.fem"
* */
public void mi_saveas(String filename)
{
callFemm("mi_saveas(\"{0}\")", filename.Replace('\\', '/'));
}
#endregion
#region Mesh command
//comming soon
#endregion
#region editing command
/**
* mi copyrotate(bx, by, angle, copies, (editaction) )
– bx, by – base point for rotation
– angle – angle by which the selected objects are incrementally shifted to make each
copy. angle is measured in degrees.
– copies – number of copies to be produced from the selected objects.
* */
public void mi_copyrotate(double bx, double by, double angle, int copies, EditMode editaction)
{
callFemm("mi_copyrotate({0},{1},{2},{3},{4})", bx, by, angle, copies, editaction.GetHashCode());
}
/**
* mi copytranslate(dx, dy, copies, (editaction))
– dx,dy – distance by which the selected objects are incrementally shifted.
– copies – number of copies to be produced from the selected objects.
– editaction 0 –nodes, 1 – lines (segments), 2 –block labels, 3 – arc segments, 4- group
* */
public void mi_copytranslate(double dx, double dy, int copies, EditMode editaction)
{
callFemm("mi_copytranslate({0},{1},{2},{3})", dx, dy, copies, editaction.GetHashCode());
}
/**
* mi createradius(x,y,r)turnsacornerlocatedat(x,y)intoacurveofradiusr
* */
public void mi_createradius(double x, double y, double r)
{
callFemm("mi_createradius({0},{1},{2})", x, y, r);
}
/**
* mi moverotate(bx,by,shiftangle (editaction))
– bx, by – base point for rotation
– shiftangle – angle in degrees by which the selected objects are rotated.
– editaction 0 –nodes, 1 – lines (segments), 2 –block labels, 3 – arc segments, 4- group
* */
public void mi_moverotate(double bx, double by, double shiftangle, EditMode editaction)
{
callFemm("mi_moverotate({0},{1},{2},{3})", bx, by, shiftangle, editaction.GetHashCode());
}
/**
* mi movetranslate(dx,dy,(editaction))
– dx,dy – distance by which the selected objects are shifted.
– editaction 0 –nodes, 1 – lines (segments), 2 –block labels, 3 – arc segments, 4- group
* */
public void mi_movetranslate(double dx, double dy, EditMode editaction)
{
callFemm("mi_movetranslate({0},{1},{2})", dx, dy, editaction.GetHashCode());
}
/**
* mi scale(bx,by,scalefactor,(editaction))
– bx, by – base point for scaling
– scalefactor – a multiplier that determines how much the selected objects are scaled
– editaction 0 –nodes, 1 – lines (segments), 2 –block labels, 3 – arc segments, 4- group
* */
public void mi_scale(double bx, double by, double scalefactor, EditMode editaction)
{
callFemm("mi_scale({0},{1},{2},{3})", bx, by, scalefactor, editaction.GetHashCode());
}
/**
* mi mirror(x1,y1,x2,y2,(editaction)) mirror the selected objects about a line passing
through the points (x1,y1) and (x2,y2). Valid editaction entries are 0 for nodes, 1 for
lines (segments), 2 for block labels, 3 for arc segments, and 4 for groups
* */
public void mi_mirror(double x1, double y1, double x2, double y2, EditMode editaction)
{
callFemm("mi_mirror({0},{1},{2},{3},{4})", x1, y1, x2, y2, editaction.GetHashCode());
}
/**
* mi seteditmode(editmode) Sets the current editmode to:
– "nodes" - nodes
– "segments" - line segments
– "arcsegments" - arc segments
– "blocks" - block labels
– "group" - selected group
This command will affect all subsequent uses of the other editing commands, if they are used
WITHOUT the editaction parameter.
* */
public void mi_seteditmode(EditMode ed)
{
callFemm("mi_seteditmode(\"{0}\")", ed);
}
public enum EditMode
{
nodes = 0,
segments = 1,
blocks = 2,
arsegments = 3,
group = 4
}
#endregion
#region Zoom commands
/**
* mi zoomnatural() zooms to a “natural” view with sensible extents.
• mi zoomout() zooms out by a factor of 50%.
• mi zoomin() zoom in by a factor of 200%.
• mi zoom(x1,y1,x2,y2) Set the display area to be from the bottom left corner specified by
(x1,y1) to the top right corner specified by (x2,y2).
* */
public void mi_zoomnatural()
{
callFemm("mi_zoomnatural()");
}
public void mi_zoomout()
{
callFemm("mi_zoomout()");
}
public void mi_zoomin()
{
callFemm("mi_zoomin()");
}
public void mi_zoom(double x1, double y1, double x2, double y2)
{
callFemm("mi_zoom({0},{1},{2},{3})", x1, y1, x2, y2);
}
#endregion
#region View commands
/**
* mi_showgrid() Show the grid points.
• mi_hidegrid() Hide the grid points points.
• mi_grid_snap("flag") Setting flag to ”on” turns on snap to grid, setting flag to "off"
turns off snap to grid.
• mi_setgrid(density,"type") Change the grid spacing. The density parameter specifies the space between grid points, and the type parameter is set to "cart" for cartesian
coordinates or "polar" for polar coordinates.
• mi refreshview() Redraws the current view.
• mi minimize() minimizes the active magnetics input view.
• mi maximize() maximizes the active magnetics input view.
• mi restore() restores the active magnetics input view from a minimized or maximized
state.
• mi resize(width,height) resizes the active magnetics input window client area to width
× height.
*/
public void mi_showgrid()
{
callFemm("mi_showgrid()");
}
public void mi_hidegrid()
{
callFemm("mi_hidegrid()");
}
public void mi_grid_snap(bool snaptogrid)
{
callFemm("mi_grid_snap(\"{0}\")", snaptogrid ? "on" : "off");
}
public void mi_setgrid(double density, String type)
{
callFemm("mi_setgrid({0},\"{1}\")", density, type);
}
public void mi_refreshview()
{
callFemm("mi_refreshview()");
}
public void mi_minimize()
{
callFemm("mi_minimize()");
}
public void mi_maximize()
{
callFemm("mi_maximize()");
}
public void mi_restore()
{
callFemm("mi_restore()");
}
public void mi_resize(int w, int h)
{
callFemm("mi_resize({0},{1})", w, h);
}
#endregion
#region Object properties - material properties
/// <summary>
/// fetches the material specified by materialname from the materials library.
/// </summary>
/// <param name="materialname"></param>
/// <returns></returns>
public String mi_getmaterial(String materialname)
{
return callFemm("mi_getmaterialname({0})", materialname);
}
/// <summary>
/// Full params method for add material
/// • mi addmaterial("materialname", mu x, mu y, H c, J, Cduct, Lam d, Phi hmax,
///lam fill, LamType, Phi hx, Phi hy),NStrands,WireD adds a new material with called
///"materialname" with the material properties:
///– mu x Relative permeability in the x- or r-direction.
///– mu y Relative permeability in the y- or z-direction.
///– H c Permanent magnet coercivity in Amps/Meter.
///– J Real Applied source current density in Amps/mm2.
///– Cduct Electrical conductivity of the material in MS/m.
///– Lam d Lamination thickness in millimeters.
///– Phi hmax Hysteresis lag angle in degrees, used for nonlinear BH curves.
///– Lam fill Fraction of the volume occupied per lamination that is actually filled with
///iron (Note that this parameter defaults to 1 the femme preprocessor dialog box because,
///by default, iron completely fills the volume)
///– Lamtype Set to
///
///∗ 0 – Not laminated or laminated in plane
///∗ – laminated x or r
///∗ 2 – laminated y or z
///∗ 3 – Magnet wire
///∗ 4 – Plain stranded wire
///∗ 5 – Litz wire
///∗ 6 – Square wire
///– Phi hx Hysteresis lag in degrees in the x-direction for linear problems.
///– Phi hy Hysteresis lag in degrees in the y-direction for linear problems.
///– NStrands Number of strands in the wire build. Should be 1 for Magnet or Square wire.
///– WireD Diameter of each wire constituent strand in millimeters.
///Note that not all properties need be defined–properties that aren’t defined are assigned default
///values.
/// </summary>
/// <param name="materialname"></param>
/// <param name="mu_x"></param>
/// <param name="mu_y"></param>
/// <param name="H_c"></param>
/// <param name="J"></param>
/// <param name="Cduct"></param>
/// <param name="Lam_d"></param>
/// <param name="Phi_hmax"></param>
/// <param name="Lam_fill"></param>
/// <param name="Lamtype"></param>
/// <param name="Phi_hx"></param>
/// <param name="Phi_hy"></param>
/// <param name="NStrands"></param>
/// <param name="WireD"></param>
public void mi_addmaterial(String materialname, double mu_x, double mu_y, double H_c, double J, double Cduct,
double Lam_d, double Phi_hmax, double Lam_fill, LaminationType Lamtype, double Phi_hx, double Phi_hy, int NStrands, double WireD)
{
callFemm("mi_addmaterial(\"{0}\",{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13})",
materialname,
MyDoubleToString(mu_x),
MyDoubleToString(mu_y),
MyDoubleToString(H_c),
MyDoubleToString(J),
MyDoubleToString(Cduct),
MyDoubleToString(Lam_d),
MyDoubleToString(Phi_hmax),
MyDoubleToString(Lam_fill),
Lamtype.GetHashCode(),
MyDoubleToString(Phi_hx),
MyDoubleToString(Phi_hy),
MyDoubleToString(NStrands),
MyDoubleToString(WireD));
}
private static String MyDoubleToString(double d)
{
return (d >= 0 ? d.ToString() : "");
}
public enum LaminationType
{
NotLaminated = 0,
LaminatedXR = 1,
LaminatedYZ = 2,
MagnetWire = 3,
PlainStrandedWire = 4,
LitzWire = 5,
SquareWire = 6
}
/// <summary>
/// Default material air
/// </summary>
/// <param name="materialname"></param>
public void mi_addmaterialAir(String materialname)
{
mi_addmaterial(materialname, 1, 1, 0, 0, 0, 0, 0, 1, LaminationType.NotLaminated, 0, 0, 0, 0);
}
/// <summary>
/// Add magnet
/// </summary>
/// <param name="materialname"></param>
/// <param name="muR"></param>
/// <param name="Hc"></param>
/// <param name="Cduct"></param>
public void mi_addmaterialMagnet(String materialname, double muR, double Hc, double Cduct)
{
mi_addmaterial(materialname, muR, muR, Hc, 0, Cduct, 0, 0, 1, LaminationType.NotLaminated, 0, 0, 0, 0);
}
public void mi_addmaterialSteel(String materialname, double muR, double Cduct, double Lam_d, double Lam_fill, LaminationType Lamtype, double[] b, double[] h)
{
mi_addmaterial(materialname, muR, muR, 0, 0, Cduct, Lam_d, 0, Lam_fill, Lamtype, 0, 0, 0, 0);
if (b != null && h != null & b.Length == h.Length)
{
for (int i = 0; i < b.Length; i++)
{
mi_addbhpoint(materialname, b[i], h[i]);
}
}
}
public enum WireType
{
MagnetWire = 3,
PlainStrandedWire = 4,
LitzWire = 5,
SquareWire = 6
}
public void mi_addmaterialCopper(String materialname, double Cduct, WireType wiretype, int NStrands, double WireD)
{
mi_addmaterial(materialname, 1, 1, 0, 0, Cduct, 0, 0, 1, (LaminationType)wiretype.GetHashCode(), 0, 0, NStrands, WireD);
}
/// <summary>
/// Adds a B-H data point the the material specified by
/// the string "blockname". The point to be added has a flux density of b in units of Teslas and
/// a field intensity of h in units of Amps/Meter.
/// </summary>
/// <param name="materialname"></param>
/// <param name="b"></param>
/// <param name="h"></param>
public void mi_addbhpoint(String materialname, double b, double h)
{
if (b >= 0 && h >= 0)
callFemm("mi_addbhpoint(\"{0}\",{1},{2})", materialname, b, h);
}
/// <summary>
/// Clears all B-H data points associated with the material
/// </summary>
/// <param name="materialname"></param>
public void mi_clearbhpoints(String materialname)
{
callFemm("mi_clearbhpoints(\"{0}\")", materialname);
}
/// <summary>
/// Adds a new point property of name "pointpropname"
/// with either a specified potential a in units Webers/Meter or a point current j in units of Amps.
/// Set the unused parameter pairs to 0.
/// </summary>
/// <param name="pointpropname"></param>
/// <param name="a"></param>
/// <param name="j"></param>
public void mi_addpointprop(String pointpropname, double a, double j)
{
callFemm("mi_addpointprop(\"{0}\",{1},{2})", pointpropname, a, j);
}
/// <summary>
/// mi addboundprop("propname", A0, A1, A2, Phi, Mu, Sig, c0, c1, BdryFormat)
///adds a new boundary property with name "propname"
///– For a “Prescribed A” type boundary condition, set the A0, A1, A2 and Phi parameters
///as required. Set all other parameters to zero.
///– For a “Small Skin Depth” type boundary condtion, set the Mu to the desired relative
///permeability and Sig to the desired conductivity in MS/m. Set BdryFormat to 1 and
///all other parameters to zero.
///– To obtain a “Mixed” type boundary condition, set C1 and C0 as required and BdryFormat
///to 2. Set all other parameters to zero.
///– For a “Strategic dual image” boundary, set BdryFormat to 3 and set all other parameters
///to zero.
///– For a “Periodic” boundary condition, set BdryFormat to 4 and set all other parameters
///to zero.
///– For an “Anti-Perodic” boundary condition, set BdryFormat to 5 set all other parameters
///to zero.
/// </summary>
/// <param name="propname"></param>
/// <param name="A0"></param>
/// <param name="A1"></param>
/// <param name="A2"></param>
/// <param name="Phi"></param>
/// <param name="Mu"></param>
/// <param name="Sig"></param>
/// <param name="c0"></param>
/// <param name="c1"></param>
/// <param name="BdryFormat"></param>
public void mi_addboundprop(String propname, double A0, double A1, double A2, double Phi, double Mu, double Sig, double c0, double c1, BoundaryFormat BdryFormat)
{
callFemm("mi_addboundprop(\"{0}\",{1},{2},{3},{4},{5},{6},{7},{8},{9})",
propname, A0, A1, A2, Phi, Mu, Sig, c0, c1, BdryFormat.GetHashCode());
}
public enum BoundaryFormat
{
Prescribed_A = 0,
SmallSkinDepth = 1,
Mixed = 2,
StrategicDualImage = 3,
Periodic = 4,
AntiPeriodic = 5
}
/// <summary>
/// Set boundary properties for Prescribed A type
/// </summary>
/// <param name="propname"></param>
/// <param name="A0"></param>
/// <param name="A1"></param>
/// <param name="A2"></param>
/// <param name="Phi"></param>
public void mi_addboundprop_Prescribed_A(String propname, double A0, double A1, double A2, double Phi)
{
mi_addboundprop(propname, A0, A1, A2, Phi, 0, 0, 0, 0, BoundaryFormat.Prescribed_A);
}
public void mi_addboundprop_AntiPeriodic(String propname)
{
mi_addboundprop(propname, 0, 0, 0, 0, 0, 0, 0, 0, BoundaryFormat.AntiPeriodic);
}
public void mi_addboundprop_Periodic(String propname)
{
mi_addboundprop(propname, 0, 0, 0, 0, 0, 0, 0, 0, BoundaryFormat.Periodic);
}
/// <summary>
/// adds a new circuit property with name "circuitname" with a prescribed current, i. The
/// circuittype parameter is 0 for a parallel-connected circuit and 1 for a series-connected
/// circuit.
/// </summary>
/// <param name="circuitname"></param>
/// <param name="i"></param>
/// <param name="circuittype"></param>
public void mi_addcircprop(String circuitname, double i, CircuitType circuittype)
{
callFemm("mi_addcircprop(\"{0}\",{1},{2})", circuitname, i, circuittype.GetHashCode());
}
public enum CircuitType
{
parallel = 0,
series = 1
}
/// <summary>
/// This function allows for modification of a circuit property. The circuit property to be modified is specified by "CircName".
/// The next parameter is the number of the property to be set. The last number is the value to
/// be applied to the specified property. The various properties that can be modified are listed
/// below:
/// * propnum Symbol Description
/// 0 CircName Name of the circuit property
/// 1 i Total current
/// 2 CircType 0 = Parallel, 1 = Series
/// </summary>
/// <param name="circuitname"></param>
/// <param name="propnum"></param>
/// <param name="value"></param>
public void mi_modifycircprop(String circuitname, int propnum, double value)
{
callFemm("mi_modifycircprop(\"{0}\",{1},{2})", circuitname, propnum, value);
}
/// <summary>
/// Modify circuit current only
/// </summary>
/// <param name="circuitname"></param>
/// <param name="value"></param>
public void mi_modifycircuitCurrent(String circuitname, double value)
{
mi_modifycircprop(circuitname, 1, value);
}
/// <summary>
/// Modify circuit current only
/// </summary>
/// <param name="circuitname"></param>
/// <param name="value">real or complex-value as string</param>
public void mi_modifycircuitCurrent(string circuitname, string value)
{
callFemm("mi_modifycircprop(\"{0}\",{1},{2})", circuitname, 1, value);
}
/// <summary>
/// deletes the material named materialname.
/// </summary>
/// <param name="materialname"></param>
public void mi_deletematerial(String materialname)
{
callFemm("mi_deletematerial(\"{0}\")", materialname);
}
/// <summary>
/// deletes the boundary property named "propname".
/// </summary>
/// <param name="propname"></param>
public void mi_deleteboundprop(String propname)
{
callFemm("mi_deleteboundprop(\"{0}\")", propname);
}
/// <summary>
/// deletes the circuit named circuitname.
/// </summary>
/// <param name="circuitname"></param>
public void mi_deletecircuit(String circuitname)
{
callFemm("mi_deletecircuit(\"{0}\")", circuitname);
}
// Some modify material and boundary, comming soon
#endregion
#region Misc
/**
* mi savebitmap("filename") saves a bitmapped screenshot of the current view to the file
specified by "filename", subject to the printf-type formatting explained previously for
the savefemmfile command.
* */
public void mi_savebitmap(String filename)
{
callFemm("mi_savebitmap(\"{0}\")", filename);
}
/**
* mi savemetafile("filename") saves a metafile screenshot of the current view to the file
specified by "filename", subject to the printf-type formatting explained previously for
the savefemmfile command.
* */
public void mi_savemetafile(String filename)
{
callFemm("mi_savemetafile(\"{0}\")", filename);
}
/**
* mi close() Closes current magnetics preprocessor document and destroys magnetics preprocessor window.
* */
public void mi_close()
{
callFemm("mi_close()");
}
/**
* mi shownames(flag) This function allow the user to display or hide the block label names
on screen. To hide the block label names, flag should be 0. To display the names, the
parameter should be set to 1.
* */
public void mi_shownames(bool show)
{
callFemm("mi_shownames({0})", show ? 1 : 0);
}
/**
* mi readdxf("filename") This function imports a dxf file specified by "filename".
• mi savedxf("filename") This function saves geometry informationin a dxf file specified
by "filename".
* */
public void mi_readdxf(String filename)
{
callFemm("mi_readdxf(\"{0}\")", filename);
}
public void mi_savedxf(String filename)
{
callFemm("mi_savedxf(\"{0}\")", filename);
}
#endregion
#endregion
#region FEMM magnetic post processor commands
#region Data extraction commands
#region Point values
public class PointValues
{
public double A;//A vector potential A or flux φ
public double B1;//B1 flux density Bx if planar, Br if axisymmetric
public double B2;//B2 flux density By if planar, Bz if axisymmetric
public double Sig;//Sig electrical conductivity σ
public double E;//E stored energy density
public double H1;//H1 field intensity Hx if planar, Hr if axisymmetric
public double H2;//H2 field intensity Hy if planar, Hz if axisymmetric
public double Je;//Je eddy current density
public double Js;//Js source current density
public double Mu1;//Mu1 relative permeability µx if planar, µr if axisymmetric
public double Mu2;//Mu2 relative permeability µy if planar, µz if axisymmetric
public double Pe;//Pe Power density dissipated through ohmic losses
public double Ph;//Ph Power density dissipated by hysteresis
}
/// <summary>
/// Measure values at point
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public PointValues mo_getpointvalues(double x, double y)
{
PointValues pv = new PointValues();
String str = callFemm("mo_getpointvalues({0},{1})", x, y);
String[] ss = str.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
double[] values = new double[13];
for (int i = 0; i < 13; i++)
{
if (i < ss.Length)
{
bool b = double.TryParse(ss[i], out values[i]);
if (!b)
values[i] = double.NaN;
}
else values[i] = double.NaN;
}
pv.A = values[0];
pv.B1 = values[1];
pv.B2 = values[2];
pv.Sig = values[3];
pv.E = values[4];
pv.H1 = values[5];
pv.H2 = values[6];
pv.Je = values[7];
pv.Js = values[8];
pv.Mu1 = values[9];
pv.Mu2 = values[10];
pv.Pe = values[11];
pv.Ph = values[12];
return pv;
}
#endregion
#region Line integral
/**
* mo lineintegral(type) Calculate the line integral for the defined contour
type | name || values 1 | values 2 | values 3 | values 4
0 | B.n || total B.n | avg B.n -
1 | H.t || total H.t | avg H.t -
2 | len+area || length | surface area -
3 | StressTensorForce || DC r/x force |DC y/z force |2× r/x force |2× y/z force
4 |StressTensorTorque || DC torque |2× torque -
5 |(B.n)ˆ2 || total (B.n)ˆ2 | avg (B.n)ˆ2 -
Returns typically two (possibly complex) values as results. For force and torque results, the
2× results are only relevant for problems where ω != 0.
* */
public class LineIntegralResult
{
public double totalBn;//flux
public double avgBn;//average Bn
public double totalHt;//also: drop mmf follow the contour
public double avgHt;
public double length;
public double surface_area;
public double DCxForce;//for planar, but DC r force if axisymmetric
public double DCyForce;//for planar, but DC z force if axisymmetric
public double ACxForce;// if w!=0 (frequency of system !=0)
public double ACyForce;// if w!=0
public double DCtorque;
public double ACtorque;
public double totalBn2;
public double avgBn2;
}
public enum LineIntegralType
{
Bn = 0,
Ht = 1,
Length = 2,
Force = 3,
Torque = 4,
Bn2 = 5,
all = 10
}
// accumulate into one lir
public LineIntegralResult mo_lineintegral(LineIntegralType type, LineIntegralResult lir = null)
{
if (lir == null)
lir = new LineIntegralResult();
try
{
String str = callFemm("mo_lineintegral({0})", type.GetHashCode());
String[] ss = str.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
switch (type)
{
case LineIntegralType.Bn:
lir.totalBn = double.Parse(ss[0]);
lir.avgBn = double.Parse(ss[1]);
break;
case LineIntegralType.Ht:
lir.totalHt = double.Parse(ss[0]);
lir.avgHt = double.Parse(ss[1]);
break;
case LineIntegralType.Length:
lir.length = double.Parse(ss[0]);
lir.surface_area = double.Parse(ss[1]);
break;
case LineIntegralType.Force:
lir.DCxForce = double.Parse(ss[0]);
lir.DCyForce = double.Parse(ss[1]);
//may be 3,4th value
break;
case LineIntegralType.Torque:
lir.DCtorque = double.Parse(ss[0]);
//may be ac
break;
case LineIntegralType.Bn2:
lir.totalBn2 = double.Parse(ss[0]);
lir.avgBn2 = double.Parse(ss[1]);
break;
}
return lir;
}
catch (Exception ex)
{
log.Error(ex.Message);
return lir;
}
}
// get all result
public LineIntegralResult mo_lineintegral_full()
{
LineIntegralResult lir = new LineIntegralResult();
LineIntegralType type = 0;
for (int i = 0; i <= 5; i++)
{
type = (LineIntegralType)Enum.ToObject(typeof(LineIntegralType), i);
mo_lineintegral(type, lir);
}
return lir;
}
#endregion
#region Block integral
public enum BlockIntegralType
{
AJ = 0,
A = 1,
Magnetic_field_energy = 2,
Losses_Hysteresis = 3,
Losses_Resistive = 4,
Area_Block_cross_section = 5,
Losses_Total = 6,
Current_Total = 7,
Volume = 10,
Steady_state_Lorentz_torque = 15,
Magnetic_field_coenergy = 17,
Steady_state_weighted_stress_tensor_torque = 22
}
public double mo_blockintegral(BlockIntegralType type)
{
String s = callFemm("mo_blockintegral({0})", type.GetHashCode());
String[] ss = s.Split('\n');
Complex c = Complex.Parse(ss[0]);
return c.a;//get real part for now
}
#endregion
#region Circuit properties
public class CircuitProperties
{
public String name;
public double current;
public double volts;
public double fluxlinkage;
}
/**
* mo_getcircuitproperties("circuit") Used primarily to obtain impedance information
associated with circuit properties. Properties are returned for the circuit property named
"circuit". Three values are returned by the function. In order, these results are:
– current Current carried by the circuit
– volts Voltage drop across the circuit
– flux_re Circuit’s flux linkage
* */
public CircuitProperties mo_getcircuitproperties(String circuit)
{
String str = callFemm("mo_getcircuitproperties(\"{0}\")", circuit);
String[] ss = str.Split('\n');
CircuitProperties cp = new CircuitProperties();
cp.name = circuit;
cp.current = double.Parse(ss[0]);
cp.volts = double.Parse(ss[1]);
cp.fluxlinkage = double.Parse(ss[2]);
return cp;
}
#endregion
#endregion
#region Select commands
public enum SelectMode
{
point = 0,
contour = 1,
area = 2
}
/**
* mo seteditmode(mode) Sets the mode of the postprocessor to point, contour, or area mode.
Valid entries for mode are "point", "contour", and "area".*/
public void mo_seteditmode(SelectMode mode)
{
callFemm("mo_seteditmode(\"{0}\")", mode);
}
/**
* • mo selectblock(x,y) Select the block that contains point (x,y).
* */
public void mo_selectblock(double x, double y)
{
callFemm("mo_selectblock({0},{1})", x, y);
}
/**
* mo groupselectblock(n) Selects all of the blocks that are labeled by block labels that are
members of group n. If no number is specified (i.e. mo groupselectblock() ), all blocks
are selected.
* */
public void mo_groupselectblock(int n)
{
callFemm("mo_groupselectblock({0})", n);
}
/** • mo addcontour(x,y) Adds a contour point at (x,y). If this is the first point then it starts a
contour, if there are existing points the contour runs from the previous point to this point.
The mo addcontour command has the same functionality as a right-button-click contour
point addition when the program is running in interactive mode.
*/
public void mo_addcontour(double x, double y)
{
callFemm("mo_addcontour({0},{1})", x, y);
}
/** • mo bendcontour(angle,anglestep) Replaces the straight line formed by the last two
points in the contour by an arc that spans angle degrees. The arc is actually composed
of many straight lines, each of which is constrained to span no more than anglestep degrees. The angle parameter can take on values from -180 to 180 degrees. The anglestep
parameter must be greater than zero. If there are less than two points defined in the contour,
this command is ignored.
*/
public void mo_bendcontour(double angle, double anglestep)
{
callFemm("mo_bendcontour({0},{1})", angle, anglestep);
}
/// <summary>
/// Adds a contour point at the closest input point to (x,y).
/// If the selected point and a previous selected points lie at the ends of an arcsegment, a contour is added
/// that traces along the arcsegment. The mo selectpoint command has the same functionality as the left-button-click
/// contour point selection when the program is running in interactive mode.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
public void mo_selectpoint(double x, double y)
{
callFemm("mo_selectpoint({0},{1})", x, y);
}
/**
• mo clearcontour() Clear a prevously defined contour
• mo clearblock() Clear block selection
* */
public void mo_clearcontour()
{
callFemm("mo_clearcontour()");
}
public void mo_clearblock()
{
callFemm("mo_clearblock()");
}
#endregion
#region Zoom commands
/** mo_zoomnatural() Zoom to the natural boundaries of the geometry.
• mo_zoomin() Zoom in one level.
• mo_zoomout() Zoom out one level.
• mo zoom(x1,y1,x2,y2) Zoom to the window defined by lower left corner (x1,y1) and upper
right corner (x2,y2).*/
public void mo_zoomnatural()
{
callFemm("mo_zoomnatural()");
}
public void mo_zoomin()
{
callFemm("mo_zoomin()");
}
public void mo_zoomout()
{
callFemm("mo_zoomout()");
}
public void mo_zoom(double x1, double y1, double x2, double y2)
{
callFemm("mo_zoom({0},{1},{2},{3})", x1, y1, x2, y2);
}
#endregion
#region View commands
/**
* mo_hidedensityplot() hides the flux density plot.
*/
public void mo_hidedensityplot()
{
callFemm("mo_hidedensityplot()");
}
/**
* • mo_showdensityplot(legend,gscale,upper_B,lower_B,type) Shows the flux density
plot with options:
96
– legend Set to 0 to hide the plot legend or 1 to show the plot legend.
– gscale Set to 0 for a colour density plot or 1 for a grey scale density plot.
– upper_B Sets the upper display limit for the density plot.
– lower_B Sets the lower display limit for the density plot.
– type Type of density plot to display. Valid entries are "bmag", "breal", and "bimag"
for magnitude, real component, and imaginary component of flux density (B), respectively; "hmag", "hreal", and "himag" for magnitude, real component, and imaginary
component of field intensity (H ); and "jmag", "jreal", and "jimag" for magnitude,
real component, and imaginary component of current density (J ).
if legend is set to -1 all parameters are ignored and default values are used e.g.:
mo_showdensityplot(-1)
* */
public void mo_showdensityplot(bool showlegend, bool grayscale, double lowerlimit, double upperlimit, DensityPlotType type)
{
callFemm("mo_showdensityplot({0},{1},{2},{3},\"{4}\")", showlegend ? 1 : 0, grayscale ? 1 : 0, upperlimit, lowerlimit, type);
}
public enum DensityPlotType
{
bmag = 0,
breal = 1,
bimag = 2,
hmag = 3,
hreal = 4,
himag = 5,
jmag = 6,
jreal = 7,
jimag = 8
}
/**
* mo_hidecontourplot() Hides the contour plot.
* */
public void mo_hidecontourplot()
{
callFemm("mo_hidecontourplot()");
}
/**
• mo_showcontourplot(numcontours,lower_A,upper_A,type) shows the A contour plot
with options:
– numcontours Number of A equipotential lines to be plotted.
– upper_A Upper limit for A contours.
– lower_A Lower limit for A contours.
– type Choice of "real", "imag", or "both" to show either the real, imaginary of both
real and imaginary components of A.
If numcontours is -1 all parameters are ignored and default values are used, e.g.:
mo_showcontourplot(-1)
* */
public void mo_showcontourplot(int numcontours, double lowerlimit, double upperlimit, ContourPlotType type)
{
callFemm("mo_showcontourplot({0},{1},{2},{3})", numcontours, lowerlimit, upperlimit, type);
}
public enum ContourPlotType
{
real = 0,
imag = 1,
both = 2
}
// vector here but later
/**
* mo minimize minimizes the active magnetics output view.
• mo maximize maximizes the active magnetics output view.
• mo restore restores the active magnetics output view from a minimized or maximized state.
• mo resize(width,height) resizes the active magnetics output window client area to width
× height.
* */
public void mo_minimize()
{
callFemm("mo_minimize()");
}
public void mo_maximize()
{
callFemm("mo_maximize()");
}
public void mo_restore()
{
callFemm("mo_restore()");
}
public void mo_resize(int w, int h)
{
callFemm("mo_resize({0},{1})", w, h);
}
#endregion
#region Misc
/**
* mo close() Closes the current post-processor instance.*/
public void mo_close()
{
callFemm("mo_close()");
}
/**
• mo refreshview() Redraws the current view.*/
public void mo_refreshview()
{
callFemm("mo_refreshview()");
}
/**
• mo reload() Reloads the solution from disk.*/
public void mo_reload()
{
callFemm("mo_reload()");
}
/**
• mo savebitmap("filename") saves a bitmapped screen shot of the current view to the file
specified by "filename". Note that if you use a path you must use two backslashes (e.g.
"c:\\temp\\myfemmfile.fem"). If the file name contains a space (e.g. file names like
c:\program files\stuff) you must enclose the file name in (extra) quotes by using a \"
sequence. For example:
mo_save_bitmap("\"c:\\temp\\screenshot.bmp\"") */
public void mo_savebitmap(String filename)
{
callFemm("mo_savebitmap(\"{0}\")", filename.Replace('\\', '/'));
}
/**
• mo savemetafile("filename") saves a metafile screenshot of the current view to the file
specified by "filename", subject to the printf-type formatting explained previously for
the savebitmap command.
* */
public void mo_savemetafile(String filename)
{
callFemm("mo_savemetafile(\"{0}\")", filename.Replace('\\', '/'));
}
#region Elements-methods
//monumnodes()Returns the number of nodes in the in focus magnetics output mesh.
public int mo_numnodes()
{
String str = callFemm("mo_numnodes()");
String[] ss = str.Split('\n');
if (ss.Length == 0)
return 0;
int n = 0;
bool b = int.TryParse(ss[0], out n);
return n;
}
//• mo_numelements()Returns the number of elements in the in focus magnets outputmesh.
public int mo_numelements()
{
String str = callFemm("mo_numelements()");
String[] ss = str.Split('\n');
if (ss.Length == 0)
return 0;
int n = 0;
bool b = int.TryParse(ss[0], out n);
return n;
}
/// <summary>
/// mo_getnode(n) Returns the(x, y) or(r, z) position of the nth mesh node.
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public PointD mo_getnode(int n)
{
String str = callFemm("mo_getnode({0})", n);
String[] ss = str.Split('\n');
PointD p = new PointD();
if (ss.Length < 2)
return p;
p.X = double.Parse(ss[0]);
p.Y = double.Parse(ss[1]);
return p;
}
[Serializable]
public class Element
{
/// <summary>
/// Indices of nodes of this element (3 point made up this triangle)
/// </summary>
public int[] nodes;
/// <summary>
/// Center point of triangle
/// </summary>
public PointD center;
/// <summary>
/// element area using the length unit defined for the problem
/// </summary>
public double area;
/// <summary>
/// group number associated with the element
/// </summary>
public int group;
}
//• mogetelement(n)MOGetElement[n] returns the following proprerties for thenth element:
//1. Index of first element node
//2. Index of second element node
//3. Index of third element node
//4. x(or r) coordinate of the element centroid
//5. y(or z) coordinate of the element centroid
//6. element area using the length unit defined for the problem
//7. group number associated with the element
public Element mo_getelement(int n)
{
String str = callFemm("mo_getelement({0})", n);
String[] ss = str.Split('\n');
Element e = new Element()
{
nodes = new int[3]
{
int.Parse(ss[0]),
int.Parse(ss[1]),
int.Parse(ss[2]),
},
center = new PointD()
{
X = double.Parse(ss[3]),
Y = double.Parse(ss[4]),
},
area = double.Parse(ss[5]),
group = int.Parse(ss[6]),
};
return e;
}
#endregion
#endregion
#endregion
#region Extended commands
public double epsilon = 1e-8;
/// <summary>
/// add a segment and add it to a group
/// </summary>
/// <param name="x1"></param>
/// <param name="y1"></param>
/// <param name="x2"></param>
/// <param name="y2"></param>
/// <param name="group"></param>
public void mi_addSegmentEx(double x1, double y1, double x2, double y2, int group, bool addnode = true)
{
// if too small, just quit
if (Math.Abs(x2 - x1) < epsilon && Math.Abs(y2 - y1) < epsilon)
return;
if (addnode)
{
mi_addnode(x1, y1);
mi_addnode(x2, y2);
}
mi_addsegment(x1, y1, x2, y2);
mi_clearselected();
mi_selectsegment((x1 + x2) / 2, (y1 + y2) / 2);
mi_setsegmentprop("", 0, false, false, group);
}
/// <summary>
/// Add an arc segment and add it to a group. If addnode = true, nodes (x1,y1),(x2,y2) will be added as well
/// </summary>
/// <param name="x1"></param>
/// <param name="y1"></param>
/// <param name="x2"></param>
/// <param name="y2"></param>
/// <param name="angle">0-180 degree</param>
/// <param name="maxdegseg"></param>
/// <param name="group"></param>
/// <param name="addnode"></param>
public void mi_addArcEx(double x1, double y1, double x2, double y2, double angle, double maxdegseg, int group, bool addnode = true)
{
// if too small, just quit
if (Math.Abs(x2 - x1) < epsilon && Math.Abs(y2 - y1) < epsilon)
return;
if (addnode)
{
mi_addnode(x1, y1);
mi_addnode(x2, y2);
}
// add an arc
if (angle >= 0)
mi_addarc(x1, y1, x2, y2, angle, maxdegseg);
else mi_addarc(x2, y2, x1, y1, -angle, maxdegseg);
//calculate the middle point of the arc
double d = Math.Sqrt((y2 - y1) * (y2 - y1) + (x2 - x1) * (x2 - x1));
double vx = (y2 - y1) / d;
double vy = -(x2 - x1) / d;
double mn = d / 2 * Math.Tan(angle / 4 * Math.PI / 180);
double x = (x2 + x1) / 2 + mn * vx;
double y = (y2 + y1) / 2 + mn * vy;
// select the segment and set its group
mi_clearselected();
mi_selectarcsegment(x, y);
mi_setarcsegmentprop(maxdegseg, "", false, group);
}
/// <summary>
/// Add a block label
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="blockname">Name of this block (material name)</param>
/// <param name="group">Which group this block belongs</param>
/// <param name="magnetdirection">Magnet direction if this is magnet block</param>
/// <param name="incircuit">Circuit name if this block is conductor</param>
/// <param name="turns">How many conductors in this block</param>
/// <param name="automesh">True if Mesh automatic</param>
/// <param name="meshsize">Size of mesh if automesh = false</param>
public void mi_addBlockLabelEx(double x, double y, String blockname, int group,
double magnetdirection, String incircuit, int turns, bool automesh, double meshsize)
{
mi_addblocklabel(x, y);
mi_clearselected();
mi_selectlabel(x, y);
mi_setblockprop(blockname, automesh, meshsize, incircuit, magnetdirection, group, turns);
}
/// <summary>
/// Add magnet block
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="blockname"></param>
/// <param name="group"></param>
/// <param name="magdirection"></param>
public void mi_addBlockLabelEx(double x, double y, String blockname, int group, double magdirection)
{
mi_addBlockLabelEx(x, y, blockname, group, magdirection, "", 0, true, 0);
}
/// <summary>
/// Add a coil, conductor block
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="blockname"></param>
/// <param name="group"></param>
/// <param name="incircuit"></param>
/// <param name="turns"></param>
public void mi_addBlockLabelEx(double x, double y, String blockname, int group, String incircuit, int turns)
{
mi_addBlockLabelEx(x, y, blockname, group, 0, incircuit, turns, true, 0);
}
/// <summary>
/// Add a normal block like air or steel
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="blockname"></param>
/// <param name="group"></param>
public void mi_addBlockLabelEx(double x, double y, String blockname, int group)
{
mi_addBlockLabelEx(x, y, blockname, group, 0, "", 0, true, 0);
}
#endregion
#region Extension function that modify directly on FEMM file (since no function supports)
private static object lock_access_femm_file = new object();
/// <summary>
/// Modify comment, only work on non-opened file
/// </summary>
/// <param name="femmFile"></param>
/// <param name="comment"></param>
public static void mi_modifyFEMMComment(String femmFile, String comment)
{
lock (lock_access_femm_file)
{
String str;
using (StreamReader sr = new StreamReader(femmFile))
{
str = sr.ReadToEnd();
int index = str.IndexOf("[Comment]");
index = str.IndexOf('\"', index);
int index2 = str.IndexOf('\"', index + 1);
str = str.Remove(index, index2 - index + 1);
str = str.Insert(index, "\"" + comment + "\"");
}
using (StreamWriter sw = new StreamWriter(femmFile))
{
sw.Write(str);
}
}
}
public static String mi_getFEMMComment(String femmFile)
{
String str = null;
lock (lock_access_femm_file)
{
using (StreamReader sr = new StreamReader(femmFile))
{
str = sr.ReadToEnd();
int index = str.IndexOf("[Comment]");
index = str.IndexOf('\"', index);
int index2 = str.IndexOf('\"', index + 1);
str = str.Substring(index + 1, index2 - index - 1);
}
}
return str;
}
#endregion
#region Utils
public class Complex
{
public double a;
public double b;
public Complex(double a, double b)
{
this.a = a;
this.b = b;
}
/// <summary>
/// Convert string format a+I*b (FEMM format) to complex
/// </summary>
/// <param name="complex_number"></param>
/// <returns></returns>
public static Complex Parse(string complex_number)
{
complex_number = complex_number.Replace(" ", "").ToUpper();//remove spaces, make sure i,I become I
int i = complex_number.IndexOf("I*");
if (i < 0)
return new Complex(double.Parse(complex_number), 0);
string s_a = complex_number.Substring(0, i - 1);//before the +/- before I*
string s_b = complex_number.Substring(i - 1).Replace("I*", "");
return new Complex(double.Parse(s_a), double.Parse(s_b));
}
}
#endregion
}
}
| 36.123874 | 189 | 0.537487 | [
"MIT"
] | lehn85/pmsm_calculation | PMSM_calculation/FEMM.cs | 64,478 | C# |
using System;
namespace HelloWebSyncServer
{
public class WeatherForecast
{
public DateTime Date { get; set; }
public int TemperatureC { get; set; }
public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
public string Summary { get; set; }
}
}
| 18.6875 | 69 | 0.61204 | [
"MIT"
] | ChristianFrom/Dotmim.Sync | Samples/HelloWebSync/HelloWebSyncServer/WeatherForecast.cs | 299 | C# |
using Files.Shared.Extensions;
using Files.Controllers;
using Files.DataModels;
using Files.Shared.Enums;
using Files.Filesystem;
using Files.Helpers;
using Files.Backend.Services.Settings;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.DependencyInjection;
using CommunityToolkit.Mvvm.Input;
using Microsoft.Toolkit.Uwp;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Input;
using Windows.ApplicationModel;
using Windows.Foundation.Collections;
using Windows.Storage;
using Windows.Storage.AccessCache;
using Windows.Storage.Pickers;
using Windows.System;
using static Files.Helpers.MenuFlyoutHelper;
namespace Files.ViewModels.SettingsViewModels
{
public class PreferencesViewModel : ObservableObject, IDisposable
{
private IUserSettingsService UserSettingsService { get; } = Ioc.Default.GetService<IUserSettingsService>();
private int selectedLanguageIndex = App.AppSettings.DefaultLanguages.IndexOf(App.AppSettings.DefaultLanguage);
private Terminal selectedTerminal = App.TerminalController.Model.GetDefaultTerminal();
private int selectedDateFormatIndex = (int)Enum.Parse(typeof(TimeStyle), App.AppSettings.DisplayedTimeStyle.ToString());
private bool showRestartControl;
private List<Terminal> terminals;
private bool disposed;
private int selectedPageIndex = -1;
private bool isPageListEditEnabled;
private ReadOnlyCollection<IMenuFlyoutItem> addFlyoutItemsSource;
public ICommand EditTerminalApplicationsCommand { get; }
public ICommand OpenFilesAtStartupCommand { get; }
public PreferencesViewModel()
{
ChangePageCommand = new AsyncRelayCommand(ChangePage);
RemovePageCommand = new RelayCommand(RemovePage);
AddPageCommand = new RelayCommand<string>(async (path) => await AddPage(path));
DefaultLanguages = App.AppSettings.DefaultLanguages;
Terminals = App.TerminalController.Model.Terminals;
DateFormats = new List<string>
{
"Application".GetLocalized(),
"SystemTimeStye".GetLocalized()
};
EditTerminalApplicationsCommand = new AsyncRelayCommand(LaunchTerminalsConfigFile);
OpenFilesAtStartupCommand = new AsyncRelayCommand(OpenFilesAtStartup);
App.TerminalController.ModelChanged += ReloadTerminals;
if (UserSettingsService.PreferencesSettingsService.TabsOnStartupList != null)
{
PagesOnStartupList = new ObservableCollection<PageOnStartupViewModel>(UserSettingsService.PreferencesSettingsService.TabsOnStartupList.Select((p) => new PageOnStartupViewModel(p)));
}
else
{
PagesOnStartupList = new ObservableCollection<PageOnStartupViewModel>();
}
PagesOnStartupList.CollectionChanged += PagesOnStartupList_CollectionChanged;
var recentsItem = new MenuFlyoutSubItemViewModel("JumpListRecentGroupHeader".GetLocalized());
recentsItem.Items.Add(new MenuFlyoutItemViewModel("Home".GetLocalized(), "Home".GetLocalized(), AddPageCommand));
PopulateRecentItems(recentsItem).ContinueWith(_ =>
{
AddFlyoutItemsSource = new ReadOnlyCollection<IMenuFlyoutItem>(new IMenuFlyoutItem[] {
new MenuFlyoutItemViewModel("Browse".GetLocalized(), null, AddPageCommand),
recentsItem,
});
}, TaskScheduler.FromCurrentSynchronizationContext());
_ = DetectOpenFilesAtStartup();
}
private async Task PopulateRecentItems(MenuFlyoutSubItemViewModel menu)
{
bool hasRecents = false;
menu.Items.Add(new MenuFlyoutSeparatorViewModel());
try
{
var mostRecentlyUsed = StorageApplicationPermissions.MostRecentlyUsedList;
foreach (AccessListEntry entry in mostRecentlyUsed.Entries)
{
string mruToken = entry.Token;
var added = await FilesystemTasks.Wrap(async () =>
{
IStorageItem item = await mostRecentlyUsed.GetItemAsync(mruToken, AccessCacheOptions.FastLocationsOnly);
if (item.IsOfType(StorageItemTypes.Folder))
{
menu.Items.Add(new MenuFlyoutItemViewModel(item.Name, string.IsNullOrEmpty(item.Path) ? entry.Metadata : item.Path, AddPageCommand));
hasRecents = true;
}
});
if (added == FileSystemStatusCode.Unauthorized)
{
// Skip item until consent is provided
}
// Exceptions include but are not limited to:
// COMException, FileNotFoundException, ArgumentException, DirectoryNotFoundException
// 0x8007016A -> The cloud file provider is not running
// 0x8000000A -> The data necessary to complete this operation is not yet available
// 0x80004005 -> Unspecified error
// 0x80270301 -> ?
else if (!added)
{
await FilesystemTasks.Wrap(() =>
{
mostRecentlyUsed.Remove(mruToken);
return Task.CompletedTask;
});
System.Diagnostics.Debug.WriteLine(added.ErrorCode);
}
}
}
catch (Exception ex)
{
App.Logger.Info(ex, "Could not fetch recent items");
}
if (!hasRecents)
{
menu.Items.RemoveAt(menu.Items.Count - 1);
}
}
private void PagesOnStartupList_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (PagesOnStartupList.Count > 0)
{
UserSettingsService.PreferencesSettingsService.TabsOnStartupList = PagesOnStartupList.Select((p) => p.Path).ToList();
}
else
{
UserSettingsService.PreferencesSettingsService.TabsOnStartupList = null;
}
}
public int SelectedStartupSettingIndex => ContinueLastSessionOnStartUp ? 1 : OpenASpecificPageOnStartup ? 2 : 0;
public bool OpenNewTabPageOnStartup
{
get => UserSettingsService.PreferencesSettingsService.OpenNewTabOnStartup;
set
{
if (value != UserSettingsService.PreferencesSettingsService.OpenNewTabOnStartup)
{
UserSettingsService.PreferencesSettingsService.OpenNewTabOnStartup = value;
OnPropertyChanged();
}
}
}
public bool ContinueLastSessionOnStartUp
{
get => UserSettingsService.PreferencesSettingsService.ContinueLastSessionOnStartUp;
set
{
if (value != UserSettingsService.PreferencesSettingsService.ContinueLastSessionOnStartUp)
{
UserSettingsService.PreferencesSettingsService.ContinueLastSessionOnStartUp = value;
OnPropertyChanged();
}
}
}
public bool OpenASpecificPageOnStartup
{
get => UserSettingsService.PreferencesSettingsService.OpenSpecificPageOnStartup;
set
{
if (value != UserSettingsService.PreferencesSettingsService.OpenSpecificPageOnStartup)
{
UserSettingsService.PreferencesSettingsService.OpenSpecificPageOnStartup = value;
OnPropertyChanged();
}
}
}
public ObservableCollection<PageOnStartupViewModel> PagesOnStartupList { get; set; }
public int SelectedPageIndex
{
get => selectedPageIndex;
set
{
if (SetProperty(ref selectedPageIndex, value))
{
IsPageListEditEnabled = value >= 0;
}
}
}
public bool IsPageListEditEnabled
{
get => isPageListEditEnabled;
set => SetProperty(ref isPageListEditEnabled, value);
}
public ReadOnlyCollection<IMenuFlyoutItem> AddFlyoutItemsSource
{
get => addFlyoutItemsSource;
set => SetProperty(ref addFlyoutItemsSource, value);
}
public ICommand ChangePageCommand { get; }
public ICommand RemovePageCommand { get; }
public RelayCommand<string> AddPageCommand { get; }
public bool AlwaysOpenANewInstance
{
get => UserSettingsService.PreferencesSettingsService.AlwaysOpenNewInstance;
set
{
if (value != UserSettingsService.PreferencesSettingsService.AlwaysOpenNewInstance)
{
UserSettingsService.PreferencesSettingsService.AlwaysOpenNewInstance = value;
ApplicationData.Current.LocalSettings.Values["AlwaysOpenANewInstance"] = value; // Needed in Program.cs
OnPropertyChanged();
}
}
}
private async Task ChangePage()
{
var folderPicker = new FolderPicker();
folderPicker.FileTypeFilter.Add("*");
StorageFolder folder = await folderPicker.PickSingleFolderAsync();
if (folder != null)
{
if (SelectedPageIndex >= 0)
{
PagesOnStartupList[SelectedPageIndex] = new PageOnStartupViewModel(folder.Path);
}
}
}
private void RemovePage()
{
int index = SelectedPageIndex;
if (index >= 0)
{
PagesOnStartupList.RemoveAt(index);
if (index > 0)
{
SelectedPageIndex = index - 1;
}
else if (PagesOnStartupList.Count > 0)
{
SelectedPageIndex = 0;
}
}
}
private async Task AddPage(string path = null)
{
if (string.IsNullOrWhiteSpace(path))
{
var folderPicker = new FolderPicker();
folderPicker.FileTypeFilter.Add("*");
var folder = await folderPicker.PickSingleFolderAsync();
if (folder != null)
{
path = folder.Path;
}
}
if (path != null && PagesOnStartupList != null)
{
PagesOnStartupList.Add(new PageOnStartupViewModel(path));
}
}
public class PageOnStartupViewModel
{
public string Text
{
get
{
if (Path == "Home".GetLocalized())
{
return "Home".GetLocalized();
}
if (Path == CommonPaths.RecycleBinPath)
{
return ApplicationData.Current.LocalSettings.Values.Get("RecycleBin_Title", "Recycle Bin");
}
return Path;
}
}
public string Path { get; }
internal PageOnStartupViewModel(string path) => Path = path;
}
private void ReloadTerminals(TerminalController controller)
{
Terminals = controller.Model.Terminals;
SelectedTerminal = controller.Model.GetDefaultTerminal();
}
public List<string> DateFormats { get; set; }
public int SelectedDateFormatIndex
{
get
{
return selectedDateFormatIndex;
}
set
{
if (SetProperty(ref selectedDateFormatIndex, value))
{
App.AppSettings.DisplayedTimeStyle = (TimeStyle)value;
}
}
}
public ObservableCollection<DefaultLanguageModel> DefaultLanguages { get; set; }
public int SelectedLanguageIndex
{
get { return selectedLanguageIndex; }
set
{
if (SetProperty(ref selectedLanguageIndex, value))
{
App.AppSettings.DefaultLanguage = DefaultLanguages[value];
if (App.AppSettings.CurrentLanguage.ID != DefaultLanguages[value].ID)
{
ShowRestartControl = true;
}
else
{
ShowRestartControl = false;
}
}
}
}
public bool ShowRestartControl
{
get => showRestartControl;
set => SetProperty(ref showRestartControl, value);
}
public List<Terminal> Terminals
{
get => terminals;
set => SetProperty(ref terminals, value);
}
public Terminal SelectedTerminal
{
get { return selectedTerminal; }
set
{
if (value is not null && SetProperty(ref selectedTerminal, value))
{
App.TerminalController.Model.DefaultTerminalName = value.Name;
App.TerminalController.SaveModel();
}
}
}
public bool ShowConfirmDeleteDialog
{
get => UserSettingsService.PreferencesSettingsService.ShowConfirmDeleteDialog;
set
{
if (value != UserSettingsService.PreferencesSettingsService.ShowConfirmDeleteDialog)
{
UserSettingsService.PreferencesSettingsService.ShowConfirmDeleteDialog = value;
OnPropertyChanged();
}
}
}
public bool OpenFoldersNewTab
{
get => UserSettingsService.PreferencesSettingsService.OpenFoldersInNewTab;
set
{
if (value != UserSettingsService.PreferencesSettingsService.OpenFoldersInNewTab)
{
UserSettingsService.PreferencesSettingsService.OpenFoldersInNewTab = value;
OnPropertyChanged();
}
}
}
private async Task LaunchTerminalsConfigFile()
{
var configFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appdata:///local/settings/terminal.json"));
if (!await Launcher.LaunchFileAsync(configFile))
{
var connection = await AppServiceConnectionHelper.Instance;
if (connection != null)
{
await connection.SendMessageAsync(new ValueSet()
{
{ "Arguments", "InvokeVerb" },
{ "FilePath", configFile.Path },
{ "Verb", "open" }
});
}
}
}
private bool openInLogin;
public bool OpenInLogin
{
get => openInLogin;
set => SetProperty(ref openInLogin, value);
}
private bool canOpenInLogin;
public bool CanOpenInLogin
{
get => canOpenInLogin;
set => SetProperty(ref canOpenInLogin, value);
}
public async Task OpenFilesAtStartup()
{
var stateMode = await ReadState();
bool state = stateMode switch
{
StartupTaskState.Enabled => true,
StartupTaskState.EnabledByPolicy => true,
StartupTaskState.DisabledByPolicy => false,
StartupTaskState.DisabledByUser => false,
_ => false,
};
if (state != OpenInLogin)
{
StartupTask startupTask = await StartupTask.GetAsync("3AA55462-A5FA-4933-88C4-712D0B6CDEBB");
if (OpenInLogin)
{
await startupTask.RequestEnableAsync();
}
else
{
startupTask.Disable();
}
await DetectOpenFilesAtStartup();
}
}
public async Task DetectOpenFilesAtStartup()
{
var stateMode = await ReadState();
switch (stateMode)
{
case StartupTaskState.Disabled:
CanOpenInLogin = true;
OpenInLogin = false;
break;
case StartupTaskState.Enabled:
CanOpenInLogin = true;
OpenInLogin = true;
break;
case StartupTaskState.DisabledByPolicy:
CanOpenInLogin = false;
OpenInLogin = false;
break;
case StartupTaskState.DisabledByUser:
CanOpenInLogin = false;
OpenInLogin = false;
break;
case StartupTaskState.EnabledByPolicy:
CanOpenInLogin = false;
OpenInLogin = true;
break;
}
}
public async Task<StartupTaskState> ReadState()
{
var state = await StartupTask.GetAsync("3AA55462-A5FA-4933-88C4-712D0B6CDEBB");
return state.State;
}
public bool AreHiddenItemsVisible
{
get => UserSettingsService.PreferencesSettingsService.AreHiddenItemsVisible;
set
{
if (value != UserSettingsService.PreferencesSettingsService.AreHiddenItemsVisible)
{
UserSettingsService.PreferencesSettingsService.AreHiddenItemsVisible = value;
OnPropertyChanged();
}
}
}
public bool AreSystemItemsHidden
{
get => UserSettingsService.PreferencesSettingsService.AreSystemItemsHidden;
set
{
if (value != UserSettingsService.PreferencesSettingsService.AreSystemItemsHidden)
{
UserSettingsService.PreferencesSettingsService.AreSystemItemsHidden = value;
OnPropertyChanged();
}
}
}
public bool ShowDotFiles
{
get => UserSettingsService.PreferencesSettingsService.ShowDotFiles;
set
{
if (value != UserSettingsService.PreferencesSettingsService.ShowDotFiles)
{
UserSettingsService.PreferencesSettingsService.ShowDotFiles = value;
OnPropertyChanged();
}
}
}
public bool ShowFileExtensions
{
get => UserSettingsService.PreferencesSettingsService.ShowFileExtensions;
set
{
if (value != UserSettingsService.PreferencesSettingsService.ShowFileExtensions)
{
UserSettingsService.PreferencesSettingsService.ShowFileExtensions = value;
OnPropertyChanged();
}
}
}
public bool OpenFilesWithOneClick
{
get => UserSettingsService.PreferencesSettingsService.OpenFilesWithOneClick;
set
{
if (value != UserSettingsService.PreferencesSettingsService.OpenFilesWithOneClick)
{
UserSettingsService.PreferencesSettingsService.OpenFilesWithOneClick = value;
OnPropertyChanged();
}
}
}
public bool OpenFoldersWithOneClick
{
get => UserSettingsService.PreferencesSettingsService.OpenFoldersWithOneClick;
set
{
if (value != UserSettingsService.PreferencesSettingsService.OpenFoldersWithOneClick)
{
UserSettingsService.PreferencesSettingsService.OpenFoldersWithOneClick = value;
OnPropertyChanged();
}
}
}
public bool ListAndSortDirectoriesAlongsideFiles
{
get => UserSettingsService.PreferencesSettingsService.ListAndSortDirectoriesAlongsideFiles;
set
{
if (value != UserSettingsService.PreferencesSettingsService.ListAndSortDirectoriesAlongsideFiles)
{
UserSettingsService.PreferencesSettingsService.ListAndSortDirectoriesAlongsideFiles = value;
OnPropertyChanged();
}
}
}
public bool SearchUnindexedItems
{
get => UserSettingsService.PreferencesSettingsService.SearchUnindexedItems;
set
{
if (value != UserSettingsService.PreferencesSettingsService.SearchUnindexedItems)
{
UserSettingsService.PreferencesSettingsService.SearchUnindexedItems = value;
OnPropertyChanged();
}
}
}
public bool AreLayoutPreferencesPerFolder
{
get => UserSettingsService.PreferencesSettingsService.AreLayoutPreferencesPerFolder;
set
{
if (value != UserSettingsService.PreferencesSettingsService.AreLayoutPreferencesPerFolder)
{
UserSettingsService.PreferencesSettingsService.AreLayoutPreferencesPerFolder = value;
OnPropertyChanged();
}
}
}
public void Dispose()
{
if (!disposed)
{
App.TerminalController.ModelChanged -= ReloadTerminals;
disposed = true;
GC.SuppressFinalize(this);
}
}
~PreferencesViewModel()
{
Dispose();
}
}
}
| 35.437014 | 197 | 0.547793 | [
"MIT"
] | Creperi/Files | src/Files.Uwp/ViewModels/SettingsViewModels/PreferencesViewModel.cs | 22,788 | C# |
// ------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// ------------------------------------------------------------
namespace Microsoft.ServiceFabric.Client.Http.Serialization
{
using System;
using System.Collections.Generic;
using Microsoft.ServiceFabric.Common;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
/// <summary>
/// Converter for <see cref="NodeHealthStateChunkList" />.
/// </summary>
internal class NodeHealthStateChunkListConverter
{
/// <summary>
/// Deserializes the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from.</param>
/// <returns>The object Value.</returns>
internal static NodeHealthStateChunkList Deserialize(JsonReader reader)
{
return reader.Deserialize(GetFromJsonProperties);
}
/// <summary>
/// Gets the object from Json properties.
/// </summary>
/// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from, reader must be placed at first property.</param>
/// <returns>The object Value.</returns>
internal static NodeHealthStateChunkList GetFromJsonProperties(JsonReader reader)
{
var totalCount = default(long?);
var items = default(IEnumerable<NodeHealthStateChunk>);
do
{
var propName = reader.ReadPropertyName();
if (string.Compare("TotalCount", propName, StringComparison.Ordinal) == 0)
{
totalCount = reader.ReadValueAsLong();
}
else if (string.Compare("Items", propName, StringComparison.Ordinal) == 0)
{
items = reader.ReadList(NodeHealthStateChunkConverter.Deserialize);
}
else
{
reader.SkipPropertyValue();
}
}
while (reader.TokenType != JsonToken.EndObject);
return new NodeHealthStateChunkList(
totalCount: totalCount,
items: items);
}
/// <summary>
/// Serializes the object to JSON.
/// </summary>
/// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
/// <param name="obj">The object to serialize to JSON.</param>
internal static void Serialize(JsonWriter writer, NodeHealthStateChunkList obj)
{
// Required properties are always serialized, optional properties are serialized when not null.
writer.WriteStartObject();
if (obj.TotalCount != null)
{
writer.WriteProperty(obj.TotalCount, "TotalCount", JsonWriterExtensions.WriteLongValue);
}
if (obj.Items != null)
{
writer.WriteEnumerableProperty(obj.Items, "Items", NodeHealthStateChunkConverter.Serialize);
}
writer.WriteEndObject();
}
}
}
| 38.882353 | 144 | 0.563691 | [
"MIT"
] | MedAnd/service-fabric-client-dotnet | src/Microsoft.ServiceFabric.Client.Http/Generated/Serialization/NodeHealthStateChunkListConverter.cs | 3,305 | C# |
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Threading;
namespace ConsoleApplication
{
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine("Started");
// Process ID is insufficient because PID's may be reused.
Console.WriteLine(
$"Process identifier = {Process.GetCurrentProcess().Id}, {Process.GetCurrentProcess().StartTime:hh:mm:ss.FF}"
);
Console.WriteLine(
"Defined types = " + typeof(Program).GetTypeInfo().Assembly.DefinedTypes.Count()
);
Thread.Sleep(Timeout.Infinite);
}
}
}
| 31.678571 | 125 | 0.634724 | [
"MIT"
] | belav/sdk | src/Assets/TestProjects/WatchGlobbingApp/Program.cs | 889 | C# |
using System;
using LanguageExt.Attributes;
namespace LanguageExt.TypeClasses
{
[Typeclass]
public interface MonadTrans<OuterMonad, OuterType, InnerMonad, InnerType, A> : Typeclass
where OuterMonad : struct, Monad<OuterType, InnerType>
where InnerMonad : struct, Monad<InnerType, A>
{
NewOuterType Bind<NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B>(OuterType ma, Func<A, NewOuterType> f)
where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>;
NewOuterType Bind<NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B>(OuterType ma, Func<A, NewInnerType> f)
where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>;
NewOuterType BindAsync<NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B>(OuterType ma, Func<A, NewOuterType> f)
where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>;
NewOuterType Map<NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B>(OuterType ma, Func<A, B> f)
where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>;
NewOuterType Traverse<NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B>(OuterType ma, Func<A, B> f)
where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>;
NewOuterType Sequence<NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType>(OuterType ma)
where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, A>;
OuterType Zero();
OuterType Plus(OuterType a, OuterType b);
S Fold<S>(OuterType ma, S state, Func<S, A, S> f);
S FoldBack<S>(OuterType ma, S state, Func<S, A, S> f);
}
}
| 48.930233 | 130 | 0.695817 | [
"MIT"
] | 1iveowl/language-ext | LanguageExt.Core/TypeClasses/MonadTrans/MonadTrans.cs | 2,106 | C# |
using System.Runtime.CompilerServices;
using System.Maui;
using System.Maui.Internals;
[assembly: InternalsVisibleTo("System.Maui.Xaml.UnitTests")]
[assembly: InternalsVisibleTo("System.Maui.Build.Tasks")]
[assembly: InternalsVisibleTo("System.Maui.Xaml.Design")]
[assembly: InternalsVisibleTo("System.Maui.Loader")]// System.Maui.Loader.dll System.Maui.Xaml.XamlLoader.Load(object, string), [email protected]
[assembly: InternalsVisibleTo("Xamarin.HotReload.Forms")]
[assembly: InternalsVisibleTo("Xamarin.HotReload.UnitTests")]
[assembly: Preserve]
[assembly: XmlnsDefinition("http://xamarin.com/schemas/2014/forms", "System.Maui.Xaml")]
[assembly: XmlnsDefinition("http://xamarin.com/schemas/2014/forms/design", "System.Maui.Xaml")]
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml", "System.Maui.Xaml")]
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml", "System", AssemblyName = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml", "System", AssemblyName = "System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2009/xaml", "System.Maui.Xaml")]
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2009/xaml", "System", AssemblyName = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2009/xaml", "System", AssemblyName = "System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
#pragma warning disable CS0612 // Type or member is obsolete
[assembly: TypeForwardedTo(typeof(System.Maui.Xaml.Internals.INameScopeProvider))]
#pragma warning restore CS0612 // Type or member is obsolete
[assembly: TypeForwardedTo(typeof(System.Maui.Xaml.Diagnostics.DebuggerHelper))]
[assembly: TypeForwardedTo(typeof(System.Maui.Xaml.Diagnostics.VisualDiagnostics))]
[assembly: TypeForwardedTo(typeof(System.Maui.Xaml.Diagnostics.VisualTreeChangeEventArgs))]
[assembly: TypeForwardedTo(typeof(System.Maui.Xaml.Diagnostics.XamlSourceInfo))]
| 70.709677 | 179 | 0.792883 | [
"MIT"
] | AswinPG/maui | System.Maui.Xaml/Properties/AssemblyInfo.cs | 2,192 | C# |
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using System.Windows;
using System.Windows.Media;
using ICSharpCode.AvalonEdit.Rendering;
namespace ICSharpCode.AvalonEdit.Rendering
{
sealed class CurrentLineHighlightRenderer : IBackgroundRenderer
{
#region Fields
int line;
TextView textView;
public static readonly Color DefaultBackground = Color.FromArgb(22, 20, 220, 224);
public static readonly Color DefaultBorder = Color.FromArgb(52, 0, 255, 110);
#endregion
#region Properties
public int Line {
get { return this.Line; }
set {
if (this.line != value) {
this.line = value;
this.textView.InvalidateLayer(this.Layer);
}
}
}
public KnownLayer Layer
{
get { return KnownLayer.Selection; }
}
public Brush BackgroundBrush {
get; set;
}
public Pen BorderPen {
get; set;
}
#endregion
public CurrentLineHighlightRenderer(TextView textView)
{
if (textView == null)
throw new ArgumentNullException("textView");
this.BorderPen = new Pen(new SolidColorBrush(DefaultBorder), 1);
this.BorderPen.Freeze();
this.BackgroundBrush = new SolidColorBrush(DefaultBackground);
this.BackgroundBrush.Freeze();
this.textView = textView;
this.textView.BackgroundRenderers.Add(this);
this.line = 0;
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if(!this.textView.Options.HighlightCurrentLine)
return;
BackgroundGeometryBuilder builder = new BackgroundGeometryBuilder();
var visualLine = this.textView.GetVisualLine(line);
if (visualLine == null) return;
var linePosY = visualLine.VisualTop - this.textView.ScrollOffset.Y;
builder.AddRectangle(textView, new Rect(0, linePosY, textView.ActualWidth, visualLine.Height));
Geometry geometry = builder.CreateGeometry();
if (geometry != null) {
drawingContext.DrawGeometry(this.BackgroundBrush, this.BorderPen, geometry);
}
}
}
}
| 24.213483 | 103 | 0.707657 | [
"MIT"
] | cafemoca/MinecraftCommandStudio | AvalonEdit/ICSharpCode.AvalonEdit/Rendering/CurrentLineHighlightRenderer.cs | 2,157 | C# |
namespace TwainDotNet.TwainNative
{
/// <summary>
/// Twain spec ICAP_COMPRESSION values.
/// </summary>
public enum Compression : short
{
None = 0,
PackBits = 1,
Group31d = 2, /* Follows CCITT spec (no End Of Line) */
Group31dEol = 3, /* Follows CCITT spec (has End Of Line) */
Group32d = 4, /* Follows CCITT spec (use cap for K Factor) */
Group4 = 5, /* Follows CCITT spec */
Jpeg = 6, /* Use capability for more info */
Lzw = 7, /* Must license from Unisys and IBM to use */
Jbig = 8, /* For Bitonal images -- Added 1.7 KHL */
Png = 9, /* Added 1.8 */
Rle4 = 10, /* Added 1.8 */
Rle8 = 11, /* Added 1.8 */
BitFields = 12 /* Added 1.8 */
}
}
| 37.2 | 76 | 0.437634 | [
"MIT"
] | Knitter/twaindotnet | src/TwainDotNet/TwainNative/Compression.cs | 932 | C# |
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using Lipeg.Runtime;
using Lipeg.SDK;
using Lipeg.SDK.Tree;
#pragma warning disable CA1822 // Mark members as static
#pragma warning disable CA1307 // Specify StringComparison
namespace Lipeg.Boot
{
internal class GrammarBuilder : IGrammarBuilder
{
public Grammar Build(INode node)
{
Debug.Assert(node.Name == "grammar");
var identifier = Identifier(node[0]);
var (options, syntax, lexicals) = Content(node[1]);
return Grammar.From(identifier, options, syntax, lexicals);
}
private (IList<Option>, IList<IRule>, IList<IRule>) Content(INode node)
{
var options = new List<Option>();
var syntax = new List<IRule>();
var lexical = new List<IRule>();
foreach (var content in node.Children)
{
switch (content.Name)
{
case OpSymbols.Opts:
options.AddRange(Options(content));
break;
case OpSymbols.Syntax:
syntax.AddRange(Rules(content));
break;
case OpSymbols.Lexical:
lexical.AddRange(Rules(content));
break;
default:
throw new InternalErrorException($"expected '{OpSymbols.Opts}', '{OpSymbols.Syntax}' or '{OpSymbols.Lexical}' but found '{content.Name}'");
}
}
return (options, syntax, lexical);
}
private IEnumerable<Option> Options(INode node)
{
Debug.Assert(node.Name == "options");
return node.Children.Select(Option);
}
private Option Option(INode node)
{
return SDK.Tree.Option.From(Identifier(node[0]), OptionValue.From(QualifiedIdentifier(node[1])));
}
private Identifier Identifier(INode node)
{
return SDK.Tree.Identifier.From(node, ((ILeaf)node).Value);
}
private Identifier QualifiedIdentifier(INode node)
{
Debug.Assert(node.Name == "qualifiedIdentifier");
var identifiers = node.Children.Select(Identifier);
return SDK.Tree.Identifier.From(node, identifiers);
}
private IEnumerable<IRule> Rules(INode node)
{
Debug.Assert(node.Name == "syntax" || node.Name == "lexical");
return node.Children.Select(Rule);
}
private IRule Rule(INode node)
{
var identifier = Identifier(node[0]);
var expression = Expression(node[1]);
return SDK.Tree.Rule.From(identifier, expression);
}
private Expression Expression(INode node)
{
Debug.Assert(node.Name == "choice");
if (node.Count > 1)
{
var choices = node.Children.Select(Sequence);
return ChoiceExpression.From(node, choices);
}
return Sequence(node[0]);
}
private Expression Sequence(INode node)
{
Debug.Assert(node.Name == "sequence");
if (node.Count > 1)
{
var prefixes = node.Children.Select(Prefix);
return SequenceExpression.From(node, prefixes);
}
return Prefix(node[0]);
}
private Expression Prefix(INode node)
{
switch (node.Name)
{
case "and":
return AndExpression.From(node, Suffix(node[0]));
case "not":
return NotExpression.From(node, Suffix(node[0]));
case "lift":
return LiftExpression.From(node, Suffix(node[0]));
case "drop":
return DropExpression.From(node, Suffix(node[0]));
case "fuse":
return FuseExpression.From(node, Suffix(node[0]));
default:
return Suffix(node);
}
}
private Expression Suffix(INode node)
{
if (node.Name == "quantified")
{
Debug.Assert(node.Count == 2);
var expression = Primary(node[0]);
switch (node[1].Name)
{
case "?":
return OptionalExpression.From(node, expression);
case "*":
return StarExpression.From(node, expression);
case "+":
return PlusExpression.From(node, expression);
default:
throw new NotImplementedException();
}
}
return Primary(node);
}
private Expression Primary(INode node)
{
switch (node.Name)
{
case "identifier":
return NameExpression.From(node, Identifier(node));
case "singleString":
case "doubleString":
return StringLiteral(node);
case ".":
return AnyExpression.From(node);
case "choice":
return Expression(node);
case "class":
return Class(node);
case "ε":
return EpsilonExpression.From(node);
case "inline":
return InlineExpression.From(node, Rule(node[0]));
default:
throw new NotImplementedException();
}
}
private Expression StringLiteral(INode node)
{
switch (node.Name)
{
case "doubleString":
case "singleString":
return DoString(node);
default:
throw new NotImplementedException();
}
}
private Expression DoString(INode node)
{
Debug.Assert(node.Name == "singleString" || node.Name == "doubleString");
//Debug.Assert(node[0].Name == "*");
var characters = string.Join(string.Empty, node.Children.Select(c => Character(c)));
return SDK.Tree.StringLiteralExpression.From(node, characters);
}
private ClassExpression Class(INode node)
{
Debug.Assert(node.Name == "class" && node.Count == 2);
var invert = node[0].Count == 1;
var ranges = node[1].Children.Select(SingleOrRange).ToArray();
return ClassExpression.From(node, invert, ranges);
}
private ClassPartExpression SingleOrRange(INode node)
{
if (node.Name == "single")
{
Debug.Assert(node.Count == 1);
var c = Character(node[0]);
Debug.Assert(c.Length == 1);
return ClassCharExpression.From(node, c[0]);
}
else if (node.Name == "range")
{
Debug.Assert(node.Count == 2);
var c1 = Character(node[0]);
Debug.Assert(c1.Length == 1);
var c2 = Character(node[1]);
Debug.Assert(c2.Length == 1);
return ClassRangeExpression.From(node, c1[0], c2[0]);
}
throw new NotImplementedException();
}
private string Character(INode node)
{
var leaf = (ILeaf)node;
return leaf.Name switch
{
"character" => leaf.Value,
"simpleEscape" => simpleEscape(leaf.Value),
"hexEscape" => ((char)int.Parse(leaf.Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture)).ToString(CultureInfo.InvariantCulture),
"unicodeEscape" => ((char)int.Parse(leaf.Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture)).ToString(CultureInfo.InvariantCulture),
_ => throw new NotImplementedException(),
};
static string simpleEscape(string escaped)
{
return escaped
.Replace("0", "\0")
.Replace("a", "\a")
.Replace("b", "\b")
.Replace("e", "\x1B")
.Replace("f", "\f")
.Replace("n", "\n")
.Replace("r", "\r")
.Replace("t", "\t")
.Replace("v", "\v");
}
}
}
}
| 31.837545 | 163 | 0.487017 | [
"MIT"
] | knutjelitto/Lingu | Lipeg.Boot/GrammarBuilder.cs | 8,822 | C# |
/*
* Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
* See https://github.com/openiddict/openiddict-core for more information concerning
* the license and the contributors participating to this project.
*/
using System.Collections.Immutable;
using Microsoft.Extensions.Logging;
using Owin;
namespace OpenIddict.Server.Owin;
public static partial class OpenIddictServerOwinHandlers
{
public static class Device
{
public static ImmutableArray<OpenIddictServerHandlerDescriptor> DefaultHandlers { get; } = ImmutableArray.Create(
/*
* Device request extraction:
*/
ExtractPostRequest<ExtractDeviceRequestContext>.Descriptor,
ExtractBasicAuthenticationCredentials<ExtractDeviceRequestContext>.Descriptor,
/*
* Device response processing:
*/
AttachHttpResponseCode<ApplyDeviceResponseContext>.Descriptor,
AttachOwinResponseChallenge<ApplyDeviceResponseContext>.Descriptor,
AttachCacheControlHeader<ApplyDeviceResponseContext>.Descriptor,
AttachWwwAuthenticateHeader<ApplyDeviceResponseContext>.Descriptor,
ProcessJsonResponse<ApplyDeviceResponseContext>.Descriptor,
/*
* Verification request extraction:
*/
ExtractGetOrPostRequest<ExtractVerificationRequestContext>.Descriptor,
/*
* Verification request handling:
*/
EnablePassthroughMode<HandleVerificationRequestContext, RequireVerificationEndpointPassthroughEnabled>.Descriptor,
/*
* Verification response processing:
*/
AttachHttpResponseCode<ApplyVerificationResponseContext>.Descriptor,
AttachOwinResponseChallenge<ApplyVerificationResponseContext>.Descriptor,
AttachCacheControlHeader<ApplyVerificationResponseContext>.Descriptor,
ProcessHostRedirectionResponse.Descriptor,
ProcessPassthroughErrorResponse<ApplyVerificationResponseContext, RequireVerificationEndpointPassthroughEnabled>.Descriptor,
ProcessLocalErrorResponse<ApplyVerificationResponseContext>.Descriptor,
ProcessEmptyResponse<ApplyVerificationResponseContext>.Descriptor);
}
/// <summary>
/// Contains the logic responsible for processing verification responses that should trigger a host redirection.
/// Note: this handler is not used when the OpenID Connect request is not initially handled by OWIN.
/// </summary>
public class ProcessHostRedirectionResponse : IOpenIddictServerHandler<ApplyVerificationResponseContext>
{
/// <summary>
/// Gets the default descriptor definition assigned to this handler.
/// </summary>
public static OpenIddictServerHandlerDescriptor Descriptor { get; }
= OpenIddictServerHandlerDescriptor.CreateBuilder<ApplyVerificationResponseContext>()
.AddFilter<RequireOwinRequest>()
.UseSingletonHandler<ProcessHostRedirectionResponse>()
.SetOrder(ProcessPassthroughErrorResponse<ApplyVerificationResponseContext, RequireVerificationEndpointPassthroughEnabled>.Descriptor.Order - 1_000)
.SetType(OpenIddictServerHandlerType.BuiltIn)
.Build();
/// <inheritdoc/>
public ValueTask HandleAsync(ApplyVerificationResponseContext context)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
// This handler only applies to OWIN requests. If The OWIN request cannot be resolved,
// this may indicate that the request was incorrectly processed by another server stack.
var response = context.Transaction.GetOwinRequest()?.Context.Response ??
throw new InvalidOperationException(SR.GetResourceString(SR.ID0120));
// Note: this handler only redirects the user agent to the address specified in
// the properties when there's no error or if the error is an access_denied error.
if (!string.IsNullOrEmpty(context.Response.Error) &&
!string.Equals(context.Response.Error, Errors.AccessDenied, StringComparison.Ordinal))
{
return default;
}
var properties = context.Transaction.GetProperty<AuthenticationProperties>(typeof(AuthenticationProperties).FullName!);
if (!string.IsNullOrEmpty(properties?.RedirectUri))
{
response.Redirect(properties.RedirectUri);
context.Logger.LogInformation(SR.GetResourceString(SR.ID6144));
context.HandleRequest();
}
return default;
}
}
}
| 46.018868 | 164 | 0.686142 | [
"Apache-2.0"
] | OrgAE/OrgAE-Openiddict | src/OpenIddict.Server.Owin/OpenIddictServerOwinHandlers.Device.cs | 4,880 | C# |
using System.IO;
using Google.Play.AssetDelivery;
using UnityEngine.AddressableAssets;
namespace Khepri.AssetDelivery.ResourceHandlers
{
public abstract class AssetPackAssetBundleResourceHandlerBase : AssetBundleResourceHandlerBase
{
protected PlayAssetPackRequest playAssetPackRequest;
protected override bool IsValidPath(string path)
{
// Only handle local bundles
if (!path.StartsWith(Addressables.RuntimePath) || !path.EndsWith(".bundle"))
{
return false;
}
return AddressablesAssetDelivery.IsPack(Path.GetFileNameWithoutExtension(path));
}
protected override float PercentComplete()
{
return ((playAssetPackRequest?.DownloadProgress ?? .0f) + (m_RequestOperation?.progress ?? .0f)) * .5f;
}
protected override void BeginOperation(string path)
{
BeginOperationImpl(Path.GetFileNameWithoutExtension(path));
}
protected abstract void BeginOperationImpl(string assetPackName);
public override void Unload()
{
base.Unload();
if (playAssetPackRequest != null)
{
playAssetPackRequest.AttemptCancel();
playAssetPackRequest = null;
}
}
}
} | 31.488372 | 115 | 0.6226 | [
"MIT"
] | Fyffe/be.khepri.play.assetdelivery.addressables | Runtime/ResourceHandlers/AssetPackAssetBundleResourceHandlerBase.cs | 1,356 | C# |
using System;
using System.Collections.Generic;
#nullable disable
namespace ProjectMann.Core.Domain
{
public partial class Proyecto
{
public Proyecto()
{
ComentarioProyectos = new HashSet<ComentarioProyecto>();
ItemTrabajoProyectos = new HashSet<ItemTrabajoProyecto>();
}
public int IdProyecto { get; set; }
public string NombreProyecto { get; set; }
public short FkEstado { get; set; }
public int FkCliente { get; set; }
public DateTime FechaCreacion { get; set; }
public DateTime FechaModificacion { get; set; }
public int FkUsuarioModifica { get; set; }
public int FkUsuarioCrea { get; set; }
public virtual Cliente FkClienteNavigation { get; set; }
public virtual Estado FkEstadoNavigation { get; set; }
public virtual Usuario FkUsuarioCreaNavigation { get; set; }
public virtual Usuario FkUsuarioModificaNavigation { get; set; }
public virtual ICollection<ComentarioProyecto> ComentarioProyectos { get; set; }
public virtual ICollection<ItemTrabajoProyecto> ItemTrabajoProyectos { get; set; }
}
}
| 35.727273 | 90 | 0.664122 | [
"MIT"
] | GabrielNunez23/ProjectMann | src/ProjectMann.Core/Domain/Proyecto.cs | 1,181 | C# |
using System.Transactions;
using Perpetuum.Accounting.Characters;
using Perpetuum.Data;
using Perpetuum.Groups.Corporations;
using Perpetuum.Host.Requests;
namespace Perpetuum.RequestHandlers
{
public class PBSSetReimburseInfo : PbsReimburseRequestHander
{
public override void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var baseEid = request.Data.GetOrDefault<long>(k.baseEID);
var forCorporation = request.Data.GetOrDefault<int>(k.forCorporation).ToBool();
var character = request.Session.Character;
long? corporationEid = null;
if (forCorporation)
{
var corporation = character.GetPrivateCorporationOrThrow();
corporation.IsAnyRole(character, CorporationRole.CEO, CorporationRole.DeputyCEO).ThrowIfFalse(ErrorCodes.InsufficientPrivileges);
character = Character.Get(request.Data.GetOrDefault<int>(k.characterID));
character.CorporationEid.ThrowIfNotEqual(corporation.Eid, ErrorCodes.NotMemberOfCorporation);
corporation.IsAnyRole(character, CorporationRole.CEO, CorporationRole.DeputyCEO).ThrowIfFalse(ErrorCodes.InsufficientPrivileges);
Db.Query().CommandText("delete pbsreimburse where corporationeid = @corporationeid").SetParameter("@corporationeid", corporation.Eid).ExecuteNonQuery();
corporationEid = corporation.Eid;
}
else
{
Db.Query().CommandText("delete pbsreimburse where characterid = @characterid and corporationeid is null").SetParameter("@characterid", character.Id).ExecuteNonQuery();
}
Db.Query().CommandText("insert into pbsreimburse (characterid,corporationeid,baseeid) values (@characterid,@corporationeid,@baseeid)")
.SetParameter("@characterid", character.Id)
.SetParameter("@corporationeid", corporationEid)
.SetParameter("@baseeid", baseEid)
.ExecuteNonQuery().ThrowIfEqual(0, ErrorCodes.SQLInsertError);
Transaction.Current.OnCommited(() => SendReimburseInfo(request, forCorporation));
scope.Complete();
}
}
}
} | 48.08 | 187 | 0.639351 | [
"MIT"
] | LoyalServant/PerpetuumServerCore | Perpetuum.RequestHandlers/PbsSetReimburseInfo.cs | 2,404 | C# |
using System.Threading.Tasks;
using AspNetDemo.Models;
using AspNetDemo.Services;
using IdRamp.Passport;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
namespace AspNetDemo.Pages.Passport
{
[Authorize(AuthenticationSchemes = AuthConstants.CookieScheme)]
public class ConnectionProofModel : PageModel
{
private readonly ProofApiService _passportService;
public ConnectionProofModel(ProofApiService passportService)
{
_passportService = passportService;
}
public CreateProofRequestResultModel Proof { get; set; }
public async Task<IActionResult> OnGet()
{
string connectionId = User.GetConnectionId();
if (connectionId == null)
return RedirectToPage("./Connect", new { returnUrl = Url.Page("./ConnectionProof") });
Proof = await _passportService.GetEmailProof(connectionId);
return Page();
}
public async Task<IActionResult> OnGetProofStatusAsync(string proofId)
{
ProofState state = await _passportService.GetProofState(proofId);
if (state == ProofState.Accepted)
return new JsonResult(true);
else
return new JsonResult(false);
}
}
}
| 30.222222 | 102 | 0.661029 | [
"MIT"
] | idramp/passportapi-aspnetcore-sample | src/AspNetDemo/Pages/Passport/ConnectionProof.cshtml.cs | 1,362 | C# |
using System;
using System.Linq;
using EventStore.Projections.Core.Services;
using EventStore.Projections.Core.Services.Processing;
using EventStore.Projections.Core.Tests.Services.projections_manager;
using NUnit.Framework;
namespace EventStore.Projections.Core.Tests.Services.v8
{
[TestFixture]
public class when_running_a_v8_projection_emitting_metadata : TestFixtureWithJsProjection
{
protected override void Given()
{
_projection = @"
fromAll().when({$any:
function(state, event) {
emit('output-stream' + event.sequenceNumber, 'emitted-event' + event.sequenceNumber, {a: JSON.parse(event.bodyRaw).a}, {m1: 1, m2: ""2""});
return {};
}});
";
}
[Test, Category("v8")]
public void process_event_returns_true()
{
string state;
EmittedEventEnvelope[] emittedEvents;
var result = _stateHandler.ProcessEvent(
"", CheckpointTag.FromPosition(0, 20, 10), "stream1", "type1", "category", Guid.NewGuid(), 0, "metadata",
@"{""a"":""b""}", out state, out emittedEvents);
Assert.IsTrue(result);
}
[Test, Category("v8")]
public void process_event_returns_emitted_event()
{
string state;
EmittedEventEnvelope[] emittedEvents;
_stateHandler.ProcessEvent(
"", CheckpointTag.FromPosition(0, 20, 10), "stream1", "type1", "category", Guid.NewGuid(), 0, "metadata",
@"{""a"":""b""}", out state, out emittedEvents);
Assert.IsNotNull(emittedEvents);
Assert.AreEqual(1, emittedEvents.Length);
Assert.AreEqual("emitted-event0", emittedEvents[0].Event.EventType);
Assert.AreEqual("output-stream0", emittedEvents[0].Event.StreamId);
Assert.AreEqual(@"{""a"":""b""}", emittedEvents[0].Event.Data);
var extraMetaData = emittedEvents[0].Event.ExtraMetaData().ToArray();
Assert.IsNotNull(extraMetaData);
Assert.AreEqual(2, extraMetaData.Length);
}
[Test, Category("v8"), Category("Manual"), Explicit]
public void can_pass_though_millions_of_events_seabiscuit_changed()
{
#if UNOFFICIALTESTING
for (var i = 0; i < 100; i++)
#else
for (var i = 0; i < 100000000; i++)
#endif
{
string state;
EmittedEventEnvelope[] emittedEvents;
_stateHandler.ProcessEvent(
"", CheckpointTag.FromPosition(0, i * 10 + 20, i * 10 + 10), "stream" + i, "type" + i, "category",
Guid.NewGuid(), i, "metadata", @"{""a"":""" + i + @"""}", out state, out emittedEvents);
Assert.IsNotNull(emittedEvents);
Assert.AreEqual(1, emittedEvents.Length);
Assert.AreEqual("emitted-event" + i, emittedEvents[0].Event.EventType);
Assert.AreEqual("output-stream" + i, emittedEvents[0].Event.StreamId);
Assert.AreEqual(@"{""a"":""" + i + @"""}", emittedEvents[0].Event.Data);
if (i % 10000 == 0)
{
Teardown();
Setup(); // recompile..
Console.Write(".");
}
}
}
}
}
| 35.77907 | 159 | 0.61196 | [
"Apache-2.0",
"CC0-1.0"
] | cuteant/EventStore-DotNetty-Fork | src/EventStore.Projections.Core.Tests/Services/v8/when_running_a_v8_projection_emitting_metadata.cs | 3,079 | C# |
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Orleans.Providers.Streams.Common;
using Orleans.Runtime;
using Orleans.Streams;
using Orleans.TestingHost.Utils;
using Xunit;
namespace UnitTests.OrleansRuntime.Streams
{
public class PooledQueueCacheTests
{
private const int PooledBufferCount = 8;
private const int PooledBufferSize = 1 << 10; // 1K
private const int MessageSize = 1 << 7; // 128
private const int MessagesPerBuffer = 8;
private const string TestStreamNamespace = "blarg";
private class TestQueueMessage
{
private static readonly byte[] FixedMessage = new byte[MessageSize];
public StreamId StreamId;
public long SequenceNumber;
public readonly byte[] Data = FixedMessage;
public DateTime EnqueueTimeUtc = DateTime.UtcNow;
}
private class TestBatchContainer : IBatchContainer
{
public StreamId StreamId { get; set; }
public StreamSequenceToken SequenceToken { get; set; }
public byte[] Data { get; set; }
public IEnumerable<Tuple<T, StreamSequenceToken>> GetEvents<T>()
{
throw new NotImplementedException();
}
public bool ImportRequestContext()
{
throw new NotImplementedException();
}
}
private class TestCacheDataAdapter : ICacheDataAdapter
{
public IBatchContainer GetBatchContainer(ref CachedMessage cachedMessage)
{
//Deserialize payload
int readOffset = 0;
ArraySegment<byte> payload = SegmentBuilder.ReadNextBytes(cachedMessage.Segment, ref readOffset);
return new TestBatchContainer
{
StreamId = cachedMessage.StreamId,
SequenceToken = GetSequenceToken(ref cachedMessage),
Data = payload.ToArray()
};
}
public StreamSequenceToken GetSequenceToken(ref CachedMessage cachedMessage)
{
return new EventSequenceTokenV2(cachedMessage.SequenceNumber);
}
}
private class CachedMessageConverter
{
private readonly IObjectPool<FixedSizeBuffer> bufferPool;
private readonly IEvictionStrategy evictionStrategy;
private FixedSizeBuffer currentBuffer;
public CachedMessageConverter(IObjectPool<FixedSizeBuffer> bufferPool, IEvictionStrategy evictionStrategy)
{
this.bufferPool = bufferPool;
this.evictionStrategy = evictionStrategy;
}
public CachedMessage ToCachedMessage(TestQueueMessage queueMessage, DateTime dequeueTimeUtc)
{
StreamPosition streamPosition = GetStreamPosition(queueMessage);
return new CachedMessage
{
StreamId = streamPosition.StreamId,
SequenceNumber = queueMessage.SequenceNumber,
EnqueueTimeUtc = queueMessage.EnqueueTimeUtc,
DequeueTimeUtc = dequeueTimeUtc,
Segment = SerializeMessageIntoPooledSegment(queueMessage),
};
}
private StreamPosition GetStreamPosition(TestQueueMessage queueMessage)
{
StreamSequenceToken sequenceToken = new EventSequenceTokenV2(queueMessage.SequenceNumber);
return new StreamPosition(queueMessage.StreamId, sequenceToken);
}
private ArraySegment<byte> SerializeMessageIntoPooledSegment(TestQueueMessage queueMessage)
{
// serialize payload
int size = SegmentBuilder.CalculateAppendSize(queueMessage.Data);
// get segment from current block
ArraySegment<byte> segment;
if (currentBuffer == null || !currentBuffer.TryGetSegment(size, out segment))
{
// no block or block full, get new block and try again
currentBuffer = bufferPool.Allocate();
//call EvictionStrategy's OnBlockAllocated method
this.evictionStrategy.OnBlockAllocated(currentBuffer);
// if this fails with clean block, then requested size is too big
if (!currentBuffer.TryGetSegment(size, out segment))
{
string errmsg = String.Format(CultureInfo.InvariantCulture,
"Message size is too big. MessageSize: {0}", size);
throw new ArgumentOutOfRangeException(nameof(queueMessage), errmsg);
}
}
// encode namespace, offset, partitionkey, properties and payload into segment
int writeOffset = 0;
SegmentBuilder.Append(segment, ref writeOffset, queueMessage.Data);
return segment;
}
}
/// <summary>
/// Fill the cache with 2 streams.
/// Get valid cursor to start of each stream.
/// Walk each cursor until there is no more data on each stream.
/// Alternate adding messages to cache and walking cursors.
/// </summary>
[Fact, TestCategory("BVT"), TestCategory("Streaming")]
public void GoldenPathTest()
{
var bufferPool = new ObjectPool<FixedSizeBuffer>(() => new FixedSizeBuffer(PooledBufferSize));
var dataAdapter = new TestCacheDataAdapter();
var cache = new PooledQueueCache(dataAdapter, NullLogger.Instance, null, null);
var evictionStrategy = new ChronologicalEvictionStrategy(NullLogger.Instance, new TimePurgePredicate(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(10)), null, null);
evictionStrategy.PurgeObservable = cache;
var converter = new CachedMessageConverter(bufferPool, evictionStrategy);
RunGoldenPath(cache, converter, 111);
}
/// <summary>
/// Run normal golden path test, then purge the cache, and then run another golden path test.
/// Goal is to make sure cache cleans up correctly when all data is purged.
/// </summary>
[Fact, TestCategory("BVT"), TestCategory("Streaming")]
public void CacheDrainTest()
{
var bufferPool = new ObjectPool<FixedSizeBuffer>(() => new FixedSizeBuffer(PooledBufferSize));
var dataAdapter = new TestCacheDataAdapter();
var cache = new PooledQueueCache(dataAdapter, NullLogger.Instance, null, null);
var evictionStrategy = new ChronologicalEvictionStrategy(NullLogger.Instance, new TimePurgePredicate(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(10)), null, null);
evictionStrategy.PurgeObservable = cache;
var converter = new CachedMessageConverter(bufferPool, evictionStrategy);
int startSequenceNuber = 222;
startSequenceNuber = RunGoldenPath(cache, converter, startSequenceNuber);
RunGoldenPath(cache, converter, startSequenceNuber);
}
[Fact, TestCategory("BVT"), TestCategory("Streaming")]
public void AvoidCacheMissNotEmptyCache()
{
AvoidCacheMiss(false);
}
[Fact, TestCategory("BVT"), TestCategory("Streaming")]
public void AvoidCacheMissEmptyCache()
{
AvoidCacheMiss(true);
}
private void AvoidCacheMiss(bool emptyCache)
{
var bufferPool = new ObjectPool<FixedSizeBuffer>(() => new FixedSizeBuffer(PooledBufferSize));
var dataAdapter = new TestCacheDataAdapter();
var cache = new PooledQueueCache(dataAdapter, NullLogger.Instance, null, null, TimeSpan.FromSeconds(30));
var evictionStrategy = new ChronologicalEvictionStrategy(NullLogger.Instance, new TimePurgePredicate(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1)), null, null);
evictionStrategy.PurgeObservable = cache;
var converter = new CachedMessageConverter(bufferPool, evictionStrategy);
var seqNumber = 123;
var stream = StreamId.Create(TestStreamNamespace, Guid.NewGuid());
// Enqueue a message for stream
var firstSequenceNumber = EnqueueMessage(stream);
// Consume first event
var cursor = cache.GetCursor(stream, new EventSequenceTokenV2(firstSequenceNumber));
Assert.True(cache.TryGetNextMessage(cursor, out var firstContainer));
Assert.Equal(stream, firstContainer.StreamId);
Assert.Equal(firstSequenceNumber, firstContainer.SequenceToken.SequenceNumber);
// Remove first message, that was consumed
cache.RemoveOldestMessage();
if (!emptyCache)
{
// Enqueue something not related to the stream
// so the cache isn't empty
EnqueueMessage(StreamId.Create(TestStreamNamespace, Guid.NewGuid()));
EnqueueMessage(StreamId.Create(TestStreamNamespace, Guid.NewGuid()));
EnqueueMessage(StreamId.Create(TestStreamNamespace, Guid.NewGuid()));
EnqueueMessage(StreamId.Create(TestStreamNamespace, Guid.NewGuid()));
EnqueueMessage(StreamId.Create(TestStreamNamespace, Guid.NewGuid()));
EnqueueMessage(StreamId.Create(TestStreamNamespace, Guid.NewGuid()));
}
// Enqueue another message for stream
var lastSequenceNumber = EnqueueMessage(stream);
// Should be able to consume the event just pushed
Assert.True(cache.TryGetNextMessage(cursor, out var lastContainer));
Assert.Equal(stream, lastContainer.StreamId);
Assert.Equal(lastSequenceNumber, lastContainer.SequenceToken.SequenceNumber);
long EnqueueMessage(StreamId streamId)
{
var now = DateTime.UtcNow;
var msg = new TestQueueMessage
{
StreamId = streamId,
SequenceNumber = seqNumber,
};
cache.Add(new List<CachedMessage>() { converter.ToCachedMessage(msg, now) }, now);
seqNumber++;
return msg.SequenceNumber;
}
}
[Fact, TestCategory("BVT"), TestCategory("Streaming")]
public void SimpleCacheMiss()
{
var bufferPool = new ObjectPool<FixedSizeBuffer>(() => new FixedSizeBuffer(PooledBufferSize));
var dataAdapter = new TestCacheDataAdapter();
var cache = new PooledQueueCache(dataAdapter, NullLogger.Instance, null, null, TimeSpan.FromSeconds(10));
var evictionStrategy = new ChronologicalEvictionStrategy(NullLogger.Instance, new TimePurgePredicate(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1)), null, null);
evictionStrategy.PurgeObservable = cache;
var converter = new CachedMessageConverter(bufferPool, evictionStrategy);
int idx;
var seqNumber = 123;
var stream = StreamId.Create(TestStreamNamespace, Guid.NewGuid());
// First and last messages destined for stream, following messages
// destined for other streams
for (idx = 0; idx < 20; idx++)
{
var now = DateTime.UtcNow;
var msg = new TestQueueMessage
{
StreamId = (idx == 0) ? stream : StreamId.Create(TestStreamNamespace, Guid.NewGuid()),
SequenceNumber = seqNumber + idx,
};
cache.Add(new List<CachedMessage>() { converter.ToCachedMessage(msg, now) }, now);
}
var cursor = cache.GetCursor(stream, new EventSequenceTokenV2(seqNumber));
// Remove first message
cache.RemoveOldestMessage();
// Enqueue a new message for stream
{
idx++;
var now = DateTime.UtcNow;
var msg = new TestQueueMessage
{
StreamId = stream,
SequenceNumber = seqNumber + idx,
};
cache.Add(new List<CachedMessage>() { converter.ToCachedMessage(msg, now) }, now);
}
// Should throw since we missed the first message
Assert.Throws<QueueCacheMissException>(() => cache.TryGetNextMessage(cursor, out _));
}
private int RunGoldenPath(PooledQueueCache cache, CachedMessageConverter converter, int startOfCache)
{
int sequenceNumber = startOfCache;
IBatchContainer batch;
var stream1 = StreamId.Create(TestStreamNamespace, Guid.NewGuid());
var stream2 = StreamId.Create(TestStreamNamespace, Guid.NewGuid());
// now add messages into cache newer than cursor
// Adding enough to fill the pool
List<TestQueueMessage> messages = Enumerable.Range(0, MessagesPerBuffer * PooledBufferCount)
.Select(i => new TestQueueMessage
{
StreamId = i % 2 == 0 ? stream1 : stream2,
SequenceNumber = sequenceNumber + i
})
.ToList();
DateTime utcNow = DateTime.UtcNow;
List<CachedMessage> cachedMessages = messages
.Select(m => converter.ToCachedMessage(m, utcNow))
.ToList();
cache.Add(cachedMessages, utcNow);
sequenceNumber += MessagesPerBuffer * PooledBufferCount;
// get cursor for stream1, walk all the events in the stream using the cursor
object stream1Cursor = cache.GetCursor(stream1, new EventSequenceTokenV2(startOfCache));
int stream1EventCount = 0;
while (cache.TryGetNextMessage(stream1Cursor, out batch))
{
Assert.NotNull(stream1Cursor);
Assert.NotNull(batch);
Assert.Equal(stream1, batch.StreamId);
Assert.NotNull(batch.SequenceToken);
stream1EventCount++;
}
Assert.Equal((sequenceNumber - startOfCache) / 2, stream1EventCount);
// get cursor for stream2, walk all the events in the stream using the cursor
object stream2Cursor = cache.GetCursor(stream2, new EventSequenceTokenV2(startOfCache));
int stream2EventCount = 0;
while (cache.TryGetNextMessage(stream2Cursor, out batch))
{
Assert.NotNull(stream2Cursor);
Assert.NotNull(batch);
Assert.Equal(stream2, batch.StreamId);
Assert.NotNull(batch.SequenceToken);
stream2EventCount++;
}
Assert.Equal((sequenceNumber - startOfCache) / 2, stream2EventCount);
// Add a blocks worth of events to the cache, then walk each cursor. Do this enough times to fill the cache twice.
for (int j = 0; j < PooledBufferCount*2; j++)
{
List<TestQueueMessage> moreMessages = Enumerable.Range(0, MessagesPerBuffer)
.Select(i => new TestQueueMessage
{
StreamId = i % 2 == 0 ? stream1 : stream2,
SequenceNumber = sequenceNumber + i
})
.ToList();
utcNow = DateTime.UtcNow;
List<CachedMessage> moreCachedMessages = moreMessages
.Select(m => converter.ToCachedMessage(m, utcNow))
.ToList();
cache.Add(moreCachedMessages, utcNow);
sequenceNumber += MessagesPerBuffer;
// walk all the events in the stream using the cursor
while (cache.TryGetNextMessage(stream1Cursor, out batch))
{
Assert.NotNull(stream1Cursor);
Assert.NotNull(batch);
Assert.Equal(stream1, batch.StreamId);
Assert.NotNull(batch.SequenceToken);
stream1EventCount++;
}
Assert.Equal((sequenceNumber - startOfCache) / 2, stream1EventCount);
// walk all the events in the stream using the cursor
while (cache.TryGetNextMessage(stream2Cursor, out batch))
{
Assert.NotNull(stream2Cursor);
Assert.NotNull(batch);
Assert.Equal(stream2, batch.StreamId);
Assert.NotNull(batch.SequenceToken);
stream2EventCount++;
}
Assert.Equal((sequenceNumber - startOfCache) / 2, stream2EventCount);
}
return sequenceNumber;
}
}
}
| 44.919271 | 177 | 0.59644 | [
"MIT"
] | romanov-is-here/orleans | test/TesterInternal/OrleansRuntime/Streams/PooledQueueCacheTests.cs | 17,249 | C# |
using System.Collections.Generic;
namespace AspNetCoreTodo.Models
{
public class TodoViewModel
{
public IEnumerable<TodoItem> Items { get; set; }
}
}
| 17.1 | 56 | 0.690058 | [
"MIT"
] | MarceloMagano/dotnetCore-Todo | AspNetCoreTodo/Models/TodoViewModel.cs | 171 | C# |
// <copyright file="ManagerReminderCard.cs" company="Microsoft Corporation">
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
// </copyright>
namespace Microsoft.Teams.Apps.Timesheet.ReminderFunction.Services.AdaptiveCard
{
using System;
using System.Collections.Generic;
using System.Globalization;
using AdaptiveCards;
using Microsoft.Bot.Schema;
using Microsoft.Extensions.Localization;
using Microsoft.Teams.Apps.Timesheet.Common.Resources;
/// <summary>
/// Creates card attachment for reminder notification to be sent to manager.
/// </summary>
public static class ManagerReminderCard
{
/// <summary>
/// Get adaptive card attachment to notify manager regarding pending timesheet requests.
/// </summary>
/// <param name="localizer">String localizer for localizing user facing text.</param>
/// <param name="applicationBasePath">Application base URL.</param>
/// <param name="applicationManifestId">Manifest Id of application.</param>
/// <param name="pendingRequestCount">Pending requests count for manager.</param>
/// <returns>An adaptive card attachment.</returns>
public static Attachment GetCard(IStringLocalizer<Strings> localizer, string applicationBasePath, string applicationManifestId, int pendingRequestCount)
{
AdaptiveCard card = new AdaptiveCard(new AdaptiveSchemaVersion(1, 2))
{
Body = new List<AdaptiveElement>
{
new AdaptiveColumnSet
{
Columns = new List<AdaptiveColumn>
{
new AdaptiveColumn
{
Width = AdaptiveColumnWidth.Auto,
Items = new List<AdaptiveElement>
{
new AdaptiveImage
{
Url = new Uri($"{applicationBasePath}/images/logo.png"),
Size = AdaptiveImageSize.Medium,
},
},
},
new AdaptiveColumn
{
Items = new List<AdaptiveElement>
{
new AdaptiveTextBlock
{
Weight = AdaptiveTextWeight.Bolder,
Spacing = AdaptiveSpacing.None,
Text = localizer.GetString("ManagerReminderCardTitle"),
Wrap = true,
},
new AdaptiveTextBlock
{
Spacing = AdaptiveSpacing.None,
Text = localizer.GetString("ManagerReminderCardSubTitle"),
Wrap = true,
IsSubtle = true,
},
},
Width = AdaptiveColumnWidth.Stretch,
},
},
},
new AdaptiveTextBlock
{
Text = localizer.GetString("PendingRequests", pendingRequestCount.ToString(CultureInfo.InvariantCulture)),
Wrap = true,
},
},
Actions = new List<AdaptiveAction>
{
new AdaptiveOpenUrlAction
{
Url = new Uri($"https://teams.microsoft.com/l/entity/{applicationManifestId}/dashboard"),
Title = $"{localizer.GetString("ManagerReminderCardButtonText")}",
},
},
};
return new Attachment()
{
ContentType = AdaptiveCard.ContentType,
Content = card,
};
}
}
}
| 44.530612 | 160 | 0.448213 | [
"MIT"
] | hunaidhanfee20/timesheet-app | Source/Microsoft.Teams.Apps.Timesheet.ReminderFunction/Services/AdaptiveCard/ManagerReminderCard.cs | 4,366 | C# |
// SF API version v50.0
// Custom fields included: False
// Relationship objects included: True
using System;
using NetCoreForce.Client.Models;
using NetCoreForce.Client.Attributes;
using Newtonsoft.Json;
namespace NetCoreForce.Models
{
///<summary>
/// Case Team Member
///<para>SObject Name: CaseTeamMember</para>
///<para>Custom Object: False</para>
///</summary>
public class SfCaseTeamMember : SObject
{
[JsonIgnore]
public static string SObjectTypeName
{
get { return "CaseTeamMember"; }
}
///<summary>
/// Team Member Id
/// <para>Name: Id</para>
/// <para>SF Type: id</para>
/// <para>Nillable: False</para>
///</summary>
[JsonProperty(PropertyName = "id")]
[Updateable(false), Createable(false)]
public string Id { get; set; }
///<summary>
/// Case ID
/// <para>Name: ParentId</para>
/// <para>SF Type: reference</para>
/// <para>Nillable: False</para>
///</summary>
[JsonProperty(PropertyName = "parentId")]
[Updateable(false), Createable(true)]
public string ParentId { get; set; }
///<summary>
/// ReferenceTo: Case
/// <para>RelationshipName: Parent</para>
///</summary>
[JsonProperty(PropertyName = "parent")]
[Updateable(false), Createable(false)]
public SfCase Parent { get; set; }
///<summary>
/// Member ID
/// <para>Name: MemberId</para>
/// <para>SF Type: reference</para>
/// <para>Nillable: False</para>
///</summary>
[JsonProperty(PropertyName = "memberId")]
[Updateable(false), Createable(true)]
public string MemberId { get; set; }
///<summary>
/// Team Template Member ID
/// <para>Name: TeamTemplateMemberId</para>
/// <para>SF Type: reference</para>
/// <para>Nillable: True</para>
///</summary>
[JsonProperty(PropertyName = "teamTemplateMemberId")]
[Updateable(false), Createable(false)]
public string TeamTemplateMemberId { get; set; }
///<summary>
/// ReferenceTo: CaseTeamTemplateMember
/// <para>RelationshipName: TeamTemplateMember</para>
///</summary>
[JsonProperty(PropertyName = "teamTemplateMember")]
[Updateable(false), Createable(false)]
public SfCaseTeamTemplateMember TeamTemplateMember { get; set; }
///<summary>
/// Team Role ID
/// <para>Name: TeamRoleId</para>
/// <para>SF Type: reference</para>
/// <para>Nillable: False</para>
///</summary>
[JsonProperty(PropertyName = "teamRoleId")]
public string TeamRoleId { get; set; }
///<summary>
/// ReferenceTo: CaseTeamRole
/// <para>RelationshipName: TeamRole</para>
///</summary>
[JsonProperty(PropertyName = "teamRole")]
[Updateable(false), Createable(false)]
public SfCaseTeamRole TeamRole { get; set; }
///<summary>
/// Team Template ID
/// <para>Name: TeamTemplateId</para>
/// <para>SF Type: reference</para>
/// <para>Nillable: True</para>
///</summary>
[JsonProperty(PropertyName = "teamTemplateId")]
[Updateable(false), Createable(false)]
public string TeamTemplateId { get; set; }
///<summary>
/// ReferenceTo: CaseTeamTemplate
/// <para>RelationshipName: TeamTemplate</para>
///</summary>
[JsonProperty(PropertyName = "teamTemplate")]
[Updateable(false), Createable(false)]
public SfCaseTeamTemplate TeamTemplate { get; set; }
///<summary>
/// Created Date
/// <para>Name: CreatedDate</para>
/// <para>SF Type: datetime</para>
/// <para>Nillable: False</para>
///</summary>
[JsonProperty(PropertyName = "createdDate")]
[Updateable(false), Createable(false)]
public DateTimeOffset? CreatedDate { get; set; }
///<summary>
/// Created By ID
/// <para>Name: CreatedById</para>
/// <para>SF Type: reference</para>
/// <para>Nillable: False</para>
///</summary>
[JsonProperty(PropertyName = "createdById")]
[Updateable(false), Createable(false)]
public string CreatedById { get; set; }
///<summary>
/// ReferenceTo: User
/// <para>RelationshipName: CreatedBy</para>
///</summary>
[JsonProperty(PropertyName = "createdBy")]
[Updateable(false), Createable(false)]
public SfUser CreatedBy { get; set; }
///<summary>
/// Last Modified Date
/// <para>Name: LastModifiedDate</para>
/// <para>SF Type: datetime</para>
/// <para>Nillable: False</para>
///</summary>
[JsonProperty(PropertyName = "lastModifiedDate")]
[Updateable(false), Createable(false)]
public DateTimeOffset? LastModifiedDate { get; set; }
///<summary>
/// Last Modified By ID
/// <para>Name: LastModifiedById</para>
/// <para>SF Type: reference</para>
/// <para>Nillable: False</para>
///</summary>
[JsonProperty(PropertyName = "lastModifiedById")]
[Updateable(false), Createable(false)]
public string LastModifiedById { get; set; }
///<summary>
/// ReferenceTo: User
/// <para>RelationshipName: LastModifiedBy</para>
///</summary>
[JsonProperty(PropertyName = "lastModifiedBy")]
[Updateable(false), Createable(false)]
public SfUser LastModifiedBy { get; set; }
///<summary>
/// System Modstamp
/// <para>Name: SystemModstamp</para>
/// <para>SF Type: datetime</para>
/// <para>Nillable: False</para>
///</summary>
[JsonProperty(PropertyName = "systemModstamp")]
[Updateable(false), Createable(false)]
public DateTimeOffset? SystemModstamp { get; set; }
}
}
| 28.461957 | 66 | 0.663357 | [
"MIT"
] | Mintish/NetCoreForce | src/NetCoreForce.Models/SfCaseTeamMember.cs | 5,237 | C# |
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace AdvantageTool.Resources {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
public class Localization {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Localization() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
public static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("AdvantageTool.Resources.Localization", typeof(Localization).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
public static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to About.
/// </summary>
public static string About {
get {
return ResourceManager.GetString("About", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to This is an LTI Advantage demonstration tool using .NET Core..
/// </summary>
public static string AboutLTITool {
get {
return ResourceManager.GetString("AboutLTITool", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Access Token URL.
/// </summary>
public static string AccessTokenUrl {
get {
return ResourceManager.GetString("AccessTokenUrl", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The tool can request an access token using this endpoint (for example to use the Names and Role Service)..
/// </summary>
public static string AccessTokenUrlDescription {
get {
return ResourceManager.GetString("AccessTokenUrlDescription", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Authorization URL.
/// </summary>
public static string AuthorizationUrl {
get {
return ResourceManager.GetString("AuthorizationUrl", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The tool requests the identity token from this endpoint..
/// </summary>
public static string AuthorizationUrlDescription {
get {
return ResourceManager.GetString("AuthorizationUrlDescription", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Back to List.
/// </summary>
public static string BackToList {
get {
return ResourceManager.GetString("BackToList", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Client ID.
/// </summary>
public static string ClientId {
get {
return ResourceManager.GetString("ClientId", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Configure your Platform to launch this Tool....
/// </summary>
public static string ConfigurePlatformToLaunch {
get {
return ResourceManager.GetString("ConfigurePlatformToLaunch", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Create.
/// </summary>
public static string Create {
get {
return ResourceManager.GetString("Create", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Create a new account..
/// </summary>
public static string CreateNewAccount {
get {
return ResourceManager.GetString("CreateNewAccount", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Deep Linking Launch URL.
/// </summary>
public static string DeepLinkingLaunchUrl {
get {
return ResourceManager.GetString("DeepLinkingLaunchUrl", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The URL to launch the tool's deep linking experience..
/// </summary>
public static string DeepLinkingLaunchUrlDescription {
get {
return ResourceManager.GetString("DeepLinkingLaunchUrlDescription", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Delete.
/// </summary>
public static string Delete {
get {
return ResourceManager.GetString("Delete", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Details.
/// </summary>
public static string Details {
get {
return ResourceManager.GetString("Details", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Display Name.
/// </summary>
public static string DisplayName {
get {
return ResourceManager.GetString("DisplayName", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Edit.
/// </summary>
public static string Edit {
get {
return ResourceManager.GetString("Edit", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to for development keys see.
/// </summary>
public static string ForDevelopmentKeysSee {
get {
return ResourceManager.GetString("ForDevelopmentKeysSee", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Getting Started.
/// </summary>
public static string GettingStarted {
get {
return ResourceManager.GetString("GettingStarted", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Home.
/// </summary>
public static string Home {
get {
return ResourceManager.GetString("Home", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Issuer.
/// </summary>
public static string Issuer {
get {
return ResourceManager.GetString("Issuer", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to This is the Issuer for all messages that originate from the Platform..
/// </summary>
public static string IssuerDescription {
get {
return ResourceManager.GetString("IssuerDescription", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to JWK Set URL.
/// </summary>
public static string JwkSetUrl {
get {
return ResourceManager.GetString("JwkSetUrl", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The tool can retrieve the platform's public keys using this endpoint..
/// </summary>
public static string JwkSetUrlDescription {
get {
return ResourceManager.GetString("JwkSetUrlDescription", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Launch URL.
/// </summary>
public static string LaunchUrl {
get {
return ResourceManager.GetString("LaunchUrl", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The URL to launch the tool's resource link experience..
/// </summary>
public static string LaunchUrlDescription {
get {
return ResourceManager.GetString("LaunchUrlDescription", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Login URL.
/// </summary>
public static string LoginUrl {
get {
return ResourceManager.GetString("LoginUrl", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The URL to initiate the tool's OpenID Connect third party login..
/// </summary>
public static string LoginUrlDescription {
get {
return ResourceManager.GetString("LoginUrlDescription", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Logout.
/// </summary>
public static string Logout {
get {
return ResourceManager.GetString("Logout", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to No platforms have been registered..
/// </summary>
public static string NoPlatformsRegistered {
get {
return ResourceManager.GetString("NoPlatformsRegistered", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to or.
/// </summary>
public static string Or {
get {
return ResourceManager.GetString("Or", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Delete Platform.
/// </summary>
public static string PlatformDelete {
get {
return ResourceManager.GetString("PlatformDelete", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Platform Details.
/// </summary>
public static string PlatformDetails {
get {
return ResourceManager.GetString("PlatformDetails", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Register Platform.
/// </summary>
public static string PlatformRegister {
get {
return ResourceManager.GetString("PlatformRegister", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Platforms.
/// </summary>
public static string Platforms {
get {
return ResourceManager.GetString("Platforms", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Platform Settings.
/// </summary>
public static string PlatformSettings {
get {
return ResourceManager.GetString("PlatformSettings", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Please.
/// </summary>
public static string Please {
get {
return ResourceManager.GetString("Please", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Private Key.
/// </summary>
public static string PrivateKey {
get {
return ResourceManager.GetString("PrivateKey", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to This is the private key the tool will use to sign client credentials..
/// </summary>
public static string PrivateKeyDescription {
get {
return ResourceManager.GetString("PrivateKeyDescription", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Enter the private key in PEM format..
/// </summary>
public static string PrivateKeyInPEMFormat {
get {
return ResourceManager.GetString("PrivateKeyInPEMFormat", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The project is based on.
/// </summary>
public static string ProjectBasedOn {
get {
return ResourceManager.GetString("ProjectBasedOn", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Register.
/// </summary>
public static string Register {
get {
return ResourceManager.GetString("Register", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Registered Platforms.
/// </summary>
public static string RegisteredPlatforms {
get {
return ResourceManager.GetString("RegisteredPlatforms", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Register New Platform.
/// </summary>
public static string RegisterNewPlatform {
get {
return ResourceManager.GetString("RegisterNewPlatform", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Register your Platform.
/// </summary>
public static string RegisterYourPlatform {
get {
return ResourceManager.GetString("RegisterYourPlatform", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Save.
/// </summary>
public static string Save {
get {
return ResourceManager.GetString("Save", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Sign In.
/// </summary>
public static string SignIn {
get {
return ResourceManager.GetString("SignIn", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Test.
/// </summary>
public static string Test {
get {
return ResourceManager.GetString("Test", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to to configure test Tools..
/// </summary>
public static string ToConfigure {
get {
return ResourceManager.GetString("ToConfigure", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Login.
/// </summary>
public static string ToLogin {
get {
return ResourceManager.GetString("ToLogin", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Tool Settings.
/// </summary>
public static string ToolSettings {
get {
return ResourceManager.GetString("ToolSettings", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to This tool currently supports:.
/// </summary>
public static string ToolSupports {
get {
return ResourceManager.GetString("ToolSupports", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to to record the platform's OpenID Connect endpoints, and the client credentials you want this tool to use..
/// </summary>
public static string ToRecordOpenIdEndpointsAndCredentials {
get {
return ResourceManager.GetString("ToRecordOpenIdEndpointsAndCredentials", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Register.
/// </summary>
public static string ToRegister {
get {
return ResourceManager.GetString("ToRegister", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to To use this Tool with your Platform.
/// </summary>
public static string UseThisToolWithPlatform {
get {
return ResourceManager.GetString("UseThisToolWithPlatform", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ..using this OpenID Connect Login Initiation Page.
/// </summary>
public static string UsingOpenIdConnect {
get {
return ResourceManager.GetString("UsingOpenIdConnect", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Add new video.
/// </summary>
public static string VideoCreate {
get {
return ResourceManager.GetString("VideoCreate", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Delete Video.
/// </summary>
public static string VideoDelete {
get {
return ResourceManager.GetString("VideoDelete", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Edit Video.
/// </summary>
public static string VideoEdit {
get {
return ResourceManager.GetString("VideoEdit", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Id of the Video.
/// </summary>
public static string VideoId {
get {
return ResourceManager.GetString("VideoId", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to This is an unique id of the video, usually available in the video URL.
/// </summary>
public static string VideoIdDescription {
get {
return ResourceManager.GetString("VideoIdDescription", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Type of the video provider.
/// </summary>
public static string VideoProviderType {
get {
return ResourceManager.GetString("VideoProviderType", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Videos.
/// </summary>
public static string Videos {
get {
return ResourceManager.GetString("Videos", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Video Settings.
/// </summary>
public static string VideoSettings {
get {
return ResourceManager.GetString("VideoSettings", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Type of the video.
/// </summary>
public static string VideoType {
get {
return ResourceManager.GetString("VideoType", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Vimeo Player.
/// </summary>
public static string VimeoPlayer {
get {
return ResourceManager.GetString("VimeoPlayer", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Welcome!.
/// </summary>
public static string Welcome {
get {
return ResourceManager.GetString("Welcome", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Welcome Stranger!.
/// </summary>
public static string WelcomeStranger {
get {
return ResourceManager.GetString("WelcomeStranger", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Youtube Player.
/// </summary>
public static string YoutubePlayer {
get {
return ResourceManager.GetString("YoutubePlayer", resourceCulture);
}
}
}
}
| 34.775182 | 184 | 0.533017 | [
"MIT"
] | SJM18/LtiAdvantage | src/Resources/Localization.Designer.cs | 23,823 | C# |
using System;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Xml.Linq;
using Microsoft.Build.Utilities;
namespace RestSharp.Build
{
public class NuSpecUpdateTask : Task
{
private Assembly _assembly;
public string Id { get; private set; }
public string Authors { get; private set; }
public string Description { get; private set; }
public string Version { get; private set; }
public string SpecFile { get; set; }
public string SourceAssemblyFile { get; set; }
public NuSpecUpdateTask() : this(null) { }
public NuSpecUpdateTask(Assembly assembly)
{
this._assembly = assembly;
}
public override bool Execute()
{
if (string.IsNullOrEmpty(this.SpecFile))
return false;
var path = Path.GetFullPath(this.SourceAssemblyFile);
this._assembly = this._assembly ?? Assembly.LoadFile(path);
var name = this._assembly.GetName();
#if SIGNED
this.Id = name.Name + "Signed";
#else
this.Id = name.Name;
#endif
this.Authors = this.GetAuthors(this._assembly);
this.Description = this.GetDescription(this._assembly);
this.Version = this.GetVersion(this._assembly);
this.GenerateComputedSpecFile();
return true;
}
private void GenerateComputedSpecFile()
{
var doc = XDocument.Load(this.SpecFile);
var metaNode = doc.Descendants("metadata").First();
this.ReplaceToken(metaNode, "id", this.Id);
this.ReplaceToken(metaNode, "authors", this.Authors);
this.ReplaceToken(metaNode, "owners", this.Authors);
this.ReplaceToken(metaNode, "description", this.Description);
this.ReplaceToken(metaNode, "version", this.Version);
doc.Save(this.SpecFile.Replace(".nuspec", "-computed.nuspec"));
}
private void ReplaceToken(XElement metaNode, XName name, string value)
{
var node = metaNode.Element(name);
var token = string.Format("${0}$", name.ToString().TrimEnd('s'));
if (name.ToString().Equals("owners"))
{
token = "$author$";
}
if (node.Value.Equals(token, StringComparison.OrdinalIgnoreCase))
{
node.SetValue(value);
}
}
private string GetDescription(Assembly asm)
{
return this.GetAttribute<AssemblyDescriptionAttribute>(asm).Description;
}
private string GetAuthors(Assembly asm)
{
return this.GetAttribute<AssemblyCompanyAttribute>(asm).Company;
}
private string GetVersion(Assembly asm)
{
var version = asm.GetName().Version.ToString();
var attr = this.GetAttribute<AssemblyInformationalVersionAttribute>(asm);
if (attr != null)
{
version = attr.InformationalVersion;
}
return version;
}
private TAttr GetAttribute<TAttr>(Assembly asm) where TAttr : Attribute
{
var attrs = asm.GetCustomAttributes(typeof(TAttr), false);
if (attrs.Length > 0)
{
return attrs[0] as TAttr;
}
return null;
}
}
}
| 28.138211 | 85 | 0.571222 | [
"Apache-2.0"
] | BradBarnich/RestSharp | RestSharp.Build/NuSpecUpdateTask.cs | 3,463 | C# |
////////////////////////////////////////////////////////////////////////////////
//NUnit tests for "EF Core Provider for LCPI OLE DB"
// IBProvider and Contributors. 08.05.2021.
using System;
using System.Data;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using xdb=lcpi.data.oledb;
namespace EFCore_LcpiOleDb_Tests.General.Work.DBMS.Firebird.V03_0_0.D3.Query.Operators.SET_001.Equal.Complete.String.String{
////////////////////////////////////////////////////////////////////////////////
using T_DATA1 =System.String;
using T_DATA2 =System.String;
////////////////////////////////////////////////////////////////////////////////
//class TestSet_504__param__02__VN
public static class TestSet_504__param__02__VN
{
private const string c_NameOf__TABLE ="DUAL";
private sealed class MyContext:TestBaseDbContext
{
[Table(c_NameOf__TABLE)]
public sealed class TEST_RECORD
{
[Key]
[Column("ID")]
public System.Int32? TEST_ID { get; set; }
};//class TEST_RECORD
//----------------------------------------------------------------------
public DbSet<TEST_RECORD> testTable { get; set; }
//----------------------------------------------------------------------
public MyContext(xdb.OleDbTransaction tr)
:base(tr)
{
}//MyContext
};//class MyContext
//-----------------------------------------------------------------------
[Test]
public static void Test_001()
{
using(var cn=LocalCnHelper.CreateCn())
{
cn.Open();
using(var tr=cn.BeginTransaction())
{
//insert new record in external transaction
using(var db=new MyContext(tr))
{
T_DATA1 vv1="3";
T_DATA2 vv2=null;
var recs=db.testTable.Where(r => vv1 /*OP{*/ == /*}OP*/ vv2);
foreach(var r in recs)
{
TestServices.ThrowSelectedRow();
}//foreach r
db.CheckTextOfLastExecutedCommand
(new TestSqlTemplate()
.T("SELECT ").N("d","ID").EOL()
.T("FROM ").N(c_NameOf__TABLE).T(" AS ").N("d").EOL()
.T("WHERE ").P_BOOL("__Exec_V_V_0"));
}//using db
tr.Commit();
}//using tr
}//using cn
}//Test_001
//-----------------------------------------------------------------------
[Test]
public static void Test_002()
{
using(var cn=LocalCnHelper.CreateCn())
{
cn.Open();
using(var tr=cn.BeginTransaction())
{
//insert new record in external transaction
using(var db=new MyContext(tr))
{
T_DATA1 vv1="3";
T_DATA2 vv2=null;
var recs=db.testTable.Where(r => !(vv1 /*OP{*/ == /*}OP*/ vv2));
int nRecs=0;
foreach(var r in recs)
{
Assert.AreEqual
(0,
nRecs);
++nRecs;
Assert.IsTrue
(r.TEST_ID.HasValue);
Assert.AreEqual
(1,
r.TEST_ID.Value);
}//foreach r
db.CheckTextOfLastExecutedCommand
(new TestSqlTemplate()
.T("SELECT ").N("d","ID").EOL()
.T("FROM ").N(c_NameOf__TABLE).T(" AS ").N("d").EOL()
.T("WHERE ").P_BOOL("__Exec_V_0"));
Assert.AreEqual
(1,
nRecs);
}//using db
tr.Commit();
}//using tr
}//using cn
}//Test_002
};//class TestSet_504__param__02__VN
////////////////////////////////////////////////////////////////////////////////
}//namespace EFCore_LcpiOleDb_Tests.General.Work.DBMS.Firebird.V03_0_0.D3.Query.Operators.SET_001.Equal.Complete.String.String
| 25.810219 | 126 | 0.522907 | [
"MIT"
] | ibprovider/Lcpi.EFCore.LcpiOleDb | Tests/General/Source/Work/DBMS/Firebird/V03_0_0/D3/Query/Operators/SET_001/Equal/Complete/String/String/TestSet_504__param__02__VN.cs | 3,538 | C# |
//
// System.ServiceModel.EnvelopeVersion.cs
//
// Author: Duncan Mak ([email protected])
//
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.ServiceModel;
namespace System.ServiceModel
{
public sealed class EnvelopeVersion
{
const string Soap11NextReceiver = "http://schemas.xmlsoap.org/soap/actor/next";
const string Soap12NextReceiver = "http://www.w3.org/2003/05/soap-envelope/role/next";
internal const string Soap12UltimateReceiver = "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver";
string name, uri, next_destination;
string [] ultimate_destination;
static EnvelopeVersion soap11 = new EnvelopeVersion ("Soap11",
"http://schemas.xmlsoap.org/soap/envelope/",
Soap11NextReceiver,
String.Empty,
Soap11NextReceiver);
static EnvelopeVersion soap12 = new EnvelopeVersion ("Soap12",
"http://www.w3.org/2003/05/soap-envelope",
Soap12NextReceiver,
String.Empty,
Soap12UltimateReceiver,
Soap12NextReceiver);
static EnvelopeVersion none = new EnvelopeVersion ("EnvelopeNone",
"http://schemas.microsoft.com/ws/2005/05/envelope/none",
String.Empty,
null);
EnvelopeVersion (string name, string uri, string next_destination, params string [] ultimate_destination)
{
this.name = name;
this.uri = uri;
this.next_destination = next_destination;
this.ultimate_destination = ultimate_destination;
}
internal string Namespace { get { return uri; }}
public static EnvelopeVersion Soap11 {
get { return soap11; }
}
public static EnvelopeVersion Soap12 {
get { return soap12; }
}
public static EnvelopeVersion None {
get { return none; }
}
public string NextDestinationActorValue {
get { return next_destination; }
}
public string [] GetUltimateDestinationActorValues ()
{
return ultimate_destination;
}
public override string ToString ()
{
return name + "(" + uri + ")";
}
}
} | 32.173469 | 113 | 0.707897 | [
"Apache-2.0"
] | 121468615/mono | mcs/class/System.ServiceModel/System.ServiceModel/EnvelopeVersion.cs | 3,153 | C# |
using Newtonsoft.Json;
using OpenCvSharp;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ikanopu.Core {
public class CropOption {
public enum Team {
Alpha, Bravo, Watcher, None
}
/// <summary>
/// 名前が書いてあるところの幅
/// </summary>
public int BoxWidth { get; set; }
/// <summary>
/// 名前が書いてあるところの高さ
/// </summary>
public int BoxHeight { get; set; }
/// <summary>
/// 名前同士の間隔(Center to Centerで)
/// </summary>
public int MarginHeight { get; set; }
/// <summary>
/// 名前が書いてあるところの中心X座標
/// </summary>
public int BaseX { get; set; }
/// <summary>
/// Alphaチーム1人目のY座標
/// </summary>
public int AlphaY { get; set; }
/// <summary>
/// Bravoチーム1人目のY座標
/// </summary>
public int BravoY { get; set; }
/// <summary>
/// 観戦者1人目のY座標、nullの場合観戦者なし
/// </summary>
public int? WatcherY { get; set; }
#region Preset Generate
public static CropOption Generate() =>
new CropOption() {
BoxWidth = 400,
BoxHeight = 50,
MarginHeight = 75,
BaseX = 1450,
AlphaY = 240,
BravoY = 615,
WatcherY = null,
};
public static CropOption GenerateWithWatcher() =>
new CropOption() {
BoxWidth = 400,
BoxHeight = 50,
MarginHeight = 75,
BaseX = 1450,
AlphaY = 142,
BravoY = 515,
WatcherY = 905,
};
#endregion
/// <summary>
/// Optionの内容から名前クリップする座標を一式返します
/// </summary>
/// <returns></returns>
[JsonIgnore]
public IEnumerable<(Team t, Rect r)> CropPosition {
get {
// alpha
for (int i = 0; i < 4; ++i) {
yield return (Team.Alpha, new Rect(BaseX - BoxWidth / 2, AlphaY + i * MarginHeight - BoxHeight / 2, BoxWidth, BoxHeight));
}
// bravo
for (int i = 0; i < 4; ++i) {
yield return (Team.Bravo, new Rect(BaseX - BoxWidth / 2, BravoY + i * MarginHeight - BoxHeight / 2, BoxWidth, BoxHeight));
}
// watcher
if (WatcherY.HasValue) {
yield return (Team.Watcher, new Rect(BaseX - BoxWidth / 2, WatcherY.Value + 0 * MarginHeight - BoxHeight / 2, BoxWidth, BoxHeight));
yield return (Team.Watcher, new Rect(BaseX - BoxWidth / 2, WatcherY.Value + 1 * MarginHeight - BoxHeight / 2, BoxWidth, BoxHeight));
}
}
}
}
}
| 32.010989 | 152 | 0.476141 | [
"MIT"
] | kamiyaowl/ikanopu | ikanopu/Core/CropOption.cs | 3,127 | C# |
namespace Airbooking.Api.Areas.HelpPage.ModelDescriptions
{
public class KeyValuePairModelDescription : ModelDescription
{
public ModelDescription KeyModelDescription { get; set; }
public ModelDescription ValueModelDescription { get; set; }
}
} | 30.333333 | 67 | 0.74359 | [
"MIT"
] | wonderu/airbooking | Airbooking.Api/Areas/HelpPage/ModelDescriptions/KeyValuePairModelDescription.cs | 273 | C# |
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NUnit.Framework;
using RestSharp;
using System.Linq;
namespace restSharpTests
{
public class TicketDevTests
{
private readonly string baseUrl = "https://ticketing.dev";
private RestClient _client;
[SetUp]
public void Setup()
{
_client = new RestClient(baseUrl);
_client.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
}
[TestCase(201), Timeout(8000)]
public void CreateOrder_Created(int expectedstatusCode)
{
var ticketId = CreateTicket();
var result = CreateOrder(ticketId);
Assert.That(result.Length > 2);
}
[Ignore("")]
[TestCase(201), Timeout(8000)]
public void CreateTicket_Created(int expectedstatusCode)
{
var result = CreateTicket();
Assert.That(result.Length > 2);
}
[Ignore("")]
[TestCase(200), Timeout(8000)]
public void Users_Test(int expectedstatusCode)
{
// Arrange
var request = new RestRequest("/api/users/test", Method.GET);
// Act
var response = _client.ExecuteGetAsync(request).GetAwaiter().GetResult();
// Assert
Assert.That((int)response.StatusCode == expectedstatusCode);
System.Console.WriteLine(response.ResponseUri);
System.Console.WriteLine(response.StatusCode);
System.Console.WriteLine(response.Content);
}
[Ignore("")]
[TestCase(200), Timeout(8000)]
public void Signin_OK(int expectedstatusCode)
{
Signin(_client, "[email protected]", "test");
// send a request to verify
var getCurrentUserRequest = new RestRequest("/api/users/currentuser", Method.GET);
var responseGetCurrentUser = _client.ExecuteAsync(getCurrentUserRequest).GetAwaiter().GetResult();
System.Console.WriteLine(responseGetCurrentUser.ResponseUri);
var data = (JObject)JsonConvert.DeserializeObject(responseGetCurrentUser.Content);
var email = data["currentUser"]["email"].Value<string>();
Assert.That(email, Is.EqualTo("[email protected]"));
}
private string CreateOrder(string ticketIdStr)
{
try
{
var request = new RestRequest("/api/orders", Method.POST);
request.AddJsonBody(new { ticketId = ticketIdStr });
var response = _client.ExecuteAsync(request).GetAwaiter().GetResult();
System.Console.WriteLine(response.ResponseUri);
var data = (JObject)JsonConvert.DeserializeObject(response.Content);
var id = data["id"].Value<string>();
var status = data["status"].Value<string>();
var version = data["version"].Value<string>();
var TicketId = data["ticket"]["id"].Value<string>();
System.Console.WriteLine($"Order created: \n");
System.Console.WriteLine($"id: {id}\n");
System.Console.WriteLine($"status: {status}\n");
System.Console.WriteLine($"version: {version}\n");
System.Console.WriteLine($"TicketId: {TicketId}\n");
return id;
}
catch
{
return "";
}
}
private string CreateTicket()
{
try
{
Signin(_client, "[email protected]", "test");
var request = new RestRequest("/api/tickets", Method.POST);
request.AddJsonBody(new { title = "the title of an event", price = 1.99 });
var response = _client.ExecuteAsync(request).GetAwaiter().GetResult();
System.Console.WriteLine(response.ResponseUri);
var data = (JObject)JsonConvert.DeserializeObject(response.Content);
var id = data["id"].Value<string>();
var title = data["title"].Value<string>();
var price = data["price"].Value<string>();
var userId = data["userId"].Value<string>();
var version = data["version"].Value<string>();
System.Console.WriteLine($"Ticket created: \n");
System.Console.WriteLine($"id: {id}\n");
System.Console.WriteLine($"title: {title}\n");
System.Console.WriteLine($"price: {price}\n");
System.Console.WriteLine($"userId: {userId}\n");
System.Console.WriteLine($"version: {version}\n");
return id;
}
catch
{
return "";
}
}
private void Signin(RestClient client, string emailStr, string passwordStr)
{
var request = new RestRequest("/api/users/signin", Method.POST);
request.AddJsonBody(new { email = emailStr, password = passwordStr });
var response = client.ExecuteAsync(request).GetAwaiter().GetResult();
System.Console.WriteLine(response.ResponseUri);
var data = (JObject)JsonConvert.DeserializeObject(response.Content);
var email = data["user"]["email"].Value<string>();
var userId = data["user"]["id"].Value<string>();
System.Console.WriteLine($"{email} : {userId}");
//Pick-Up login Cookie and setting it to Client Cookie Container
client.CookieContainer = new System.Net.CookieContainer();
var accessToken = response.Cookies.First(c => c.Name == "session");
client.CookieContainer.Add(new System.Net.Cookie(accessToken.Name, accessToken.Value, accessToken.Path, accessToken.Domain));
// send new request to verify
var getCurrentUserRequest = new RestRequest("/api/users/currentuser", Method.GET);
var responseGetCurrentUser = client.ExecuteAsync(getCurrentUserRequest).GetAwaiter().GetResult();
System.Console.WriteLine(responseGetCurrentUser.ResponseUri);
System.Console.WriteLine(responseGetCurrentUser.Content);
}
}
}
| 39.63522 | 137 | 0.575849 | [
"MIT"
] | daviddongguo/ticketing | test/restSharpTests/TicketDevTests.cs | 6,302 | C# |
namespace Masa.Contrib.Ddd.Domain.Tests;
[TestClass]
public class DomainEventBusTest
{
private Assembly[] _defaultAssemblies = default!;
private IServiceCollection _services = default!;
private Mock<IEventBus> _eventBus = default!;
private Mock<IIntegrationEventBus> _integrationEventBus = default!;
private Mock<IUnitOfWork> _uoW = default!;
private IOptions<DispatcherOptions> _dispatcherOptions = default!;
[TestInitialize]
public void Initialize()
{
_defaultAssemblies = AppDomain.CurrentDomain.GetAssemblies();
_services = new ServiceCollection();
_eventBus = new();
_integrationEventBus = new();
_uoW = new();
_dispatcherOptions = Options.Create(new DispatcherOptions(new ServiceCollection()));
}
[TestMethod]
public void TestGetAllEventTypes()
{
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
var eventTypes = assemblies.SelectMany(assembly => assembly.GetTypes())
.Where(type => type.IsClass && typeof(IEvent).IsAssignableFrom(type));
_eventBus.Setup(eventBus => eventBus.GetAllEventTypes()).Returns(() => eventTypes);
_dispatcherOptions.Value.Assemblies = _defaultAssemblies;
var domainEventBus = new DomainEventBus(_eventBus.Object, _integrationEventBus.Object, _uoW.Object, _dispatcherOptions);
Assert.IsTrue(domainEventBus.GetAllEventTypes().Count() == eventTypes.Count(), "");
}
[TestMethod]
public async Task TestPublishDomainEventAsync()
{
var domainEventBus = new DomainEventBus(_eventBus.Object, _integrationEventBus.Object, _uoW.Object, _dispatcherOptions);
_eventBus.Setup(eventBus => eventBus.PublishAsync(It.IsAny<PaymentSucceededDomainEvent>())).Verifiable();
var domainEvent = new PaymentSucceededDomainEvent(new Random().Next(10000, 1000000).ToString());
await domainEventBus.PublishAsync(domainEvent);
_eventBus.Verify(eventBus => eventBus.PublishAsync(domainEvent), Times.Once, "PublishAsync is executed multiple times");
_integrationEventBus.Verify(integrationEventBus => integrationEventBus.PublishAsync(domainEvent), Times.Never, "integrationEventBus should not be executed");
Assert.IsTrue(domainEvent.UnitOfWork!.Equals(_uoW.Object));
}
[TestMethod]
public async Task TestPublishIntegrationDomainEventAsync()
{
var domainEventBus = new DomainEventBus(_eventBus.Object, _integrationEventBus.Object, _uoW.Object, _dispatcherOptions);
_integrationEventBus.Setup(integrationEventBus => integrationEventBus.PublishAsync(It.IsAny<PaymentFailedIntegrationDomainEvent>())).Verifiable();
var integrationDomainEvent = new PaymentFailedIntegrationDomainEvent()
{
OrderId = new Random().Next(10000, 1000000).ToString()
};
await domainEventBus.PublishAsync(integrationDomainEvent);
_eventBus.Verify(eventBus => eventBus.PublishAsync(integrationDomainEvent), Times.Never, "eventBus should not be executed");
_integrationEventBus.Verify(integrationEventBus => integrationEventBus.PublishAsync(integrationDomainEvent), Times.Once, " PublishAsync is executed multiple times");
}
[TestMethod]
public async Task TestPublishDomainCommandAsync()
{
_uoW.Setup(u => u.CommitAsync(default)).Verifiable();
var domainEventBus = new DomainEventBus(_eventBus.Object, _integrationEventBus.Object, _uoW.Object, _dispatcherOptions);
_eventBus.Setup(eventBus => eventBus.PublishAsync(It.IsAny<CreateProductDomainCommand>()))
.Callback<CreateProductDomainCommand>((domainEvent) =>
{
Mock<IRepository<Users>> userRepository = new();
var user = new Users()
{
Name = "Jim"
};
userRepository.Setup(repository => repository.AddAsync(It.IsAny<Users>(), CancellationToken.None)).Verifiable();
domainEvent.UnitOfWork!.CommitAsync();
});
var @command = new CreateProductDomainCommand()
{
Name = "Phone"
};
await domainEventBus.PublishAsync(@command);
_eventBus.Verify(eventBus => eventBus.PublishAsync(@command), Times.Once, "PublishAsync is executed multiple times");
_uoW.Verify(u => u.CommitAsync(default), Times.Once);
}
[TestMethod]
public void TestAddMultDomainEventBusAsync()
{
_services.AddScoped(serviceProvider => _eventBus.Object);
_services.AddScoped(serviceProvider => _integrationEventBus.Object);
_services.AddScoped(serviceProvider => _uoW.Object);
_services.AddDomainEventBus(options => options.Assemblies = new Assembly[1] { typeof(DomainEventBusTest).Assembly }).AddDomainEventBus();
var serviceProvider = _services.BuildServiceProvider();
Assert.IsTrue(serviceProvider.GetServices<IDomainEventBus>().Count() == 1);
Assert.IsTrue(serviceProvider.GetServices<IOptions<DispatcherOptions>>().Count() == 1);
}
[TestMethod]
public void TestNotUseEventBus()
{
var ex = Assert.ThrowsException<Exception>(()
=> _services.AddDomainEventBus()
);
Assert.IsTrue(ex.Message == "Please add EventBus first.");
}
[TestMethod]
public void TestNotUseUnitOfWork()
{
var eventBus = new Mock<IEventBus>();
_services.AddScoped(serviceProvider => eventBus.Object);
var ex = Assert.ThrowsException<Exception>(()
=> _services.AddDomainEventBus(options => options.Assemblies = new Assembly[1] { typeof(DomainEventBusTest).Assembly })
);
Assert.IsTrue(ex.Message == "Please add UoW first.");
}
[TestMethod]
public void TestNotUseIntegrationEventBus()
{
var services = new ServiceCollection();
var eventBus = new Mock<IEventBus>();
services.AddScoped(serviceProvider => eventBus.Object);
var uoW = new Mock<IUnitOfWork>();
services.AddScoped(serviceProvider => uoW.Object);
var ex = Assert.ThrowsException<Exception>(()
=> services.AddDomainEventBus(options => options.Assemblies = new Assembly[1] { typeof(DomainEventBusTest).Assembly })
);
Assert.IsTrue(ex.Message == "Please add IntegrationEventBus first.");
}
[TestMethod]
public void TestNullAssembly()
{
Assert.ThrowsException<ArgumentNullException>(() => _dispatcherOptions.Value.Assemblies = null!);
}
[TestMethod]
public void TestNotRepository()
{
var services = new ServiceCollection();
var eventBus = new Mock<IEventBus>();
services.AddScoped(serviceProvider => eventBus.Object);
var uoW = new Mock<IUnitOfWork>();
services.AddScoped(serviceProvider => uoW.Object);
var integrationEventBus = new Mock<IIntegrationEventBus>();
services.AddScoped(serviceProvider => integrationEventBus.Object);
Assert.ThrowsException<NotImplementedException>(() =>
{
services.AddDomainEventBus(options =>
{
options.Assemblies = new Assembly[1] { typeof(Users).Assembly };
});
});
}
[TestMethod]
public void TestUserRepository()
{
var services = new ServiceCollection();
var eventBus = new Mock<IEventBus>();
services.AddScoped(serviceProvider => eventBus.Object);
var uoW = new Mock<IUnitOfWork>();
services.AddScoped(serviceProvider => uoW.Object);
var integrationEventBus = new Mock<IIntegrationEventBus>();
services.AddScoped(serviceProvider => integrationEventBus.Object);
Mock<IRepository<Users>> repository = new();
services.AddScoped(serviceProvider => repository.Object);
services.AddDomainEventBus(options =>
{
options.Assemblies = new Assembly[2] { typeof(Users).Assembly, typeof(DomainEventBusTest).Assembly };
});
}
[TestMethod]
public async Task TestPublishQueueAsync()
{
var domainEvent = new PaymentSucceededDomainEvent("ef5f84db-76e4-4c79-9815-99a1543b6589");
var integrationDomainEvent = new PaymentFailedIntegrationDomainEvent { OrderId = "d65c1a0c-6e44-40ce-9737-738fa1dcdab4" };
_eventBus
.Setup(eventBus => eventBus.PublishAsync(It.IsAny<IDomainEvent>()))
.Callback(() =>
{
_integrationEventBus.Verify(integrationEventBus => integrationEventBus.PublishAsync(integrationDomainEvent), Times.Never, "Sent in the wrong order");
});
_integrationEventBus
.Setup(integrationEventBus => integrationEventBus.PublishAsync(It.IsAny<IDomainEvent>()))
.Callback(() =>
{
_eventBus.Verify(eventBus => eventBus.PublishAsync((IDomainEvent)domainEvent), Times.Once, "Sent in the wrong order");
});
var uoW = new Mock<IUnitOfWork>();
uoW.Setup(u => u.CommitAsync(default)).Verifiable();
var options = Options.Create(new DispatcherOptions(_services) { Assemblies = AppDomain.CurrentDomain.GetAssemblies() });
var domainEventBus = new DomainEventBus(_eventBus.Object, _integrationEventBus.Object, uoW.Object, options);
await domainEventBus.Enqueue(domainEvent);
await domainEventBus.Enqueue(integrationDomainEvent);
await domainEventBus.PublishQueueAsync();
_eventBus.Verify(eventBus => eventBus.PublishAsync((IDomainEvent)domainEvent), Times.Once, "Sent in the wrong order");
_integrationEventBus.Verify(integrationEventBus => integrationEventBus.PublishAsync(integrationDomainEvent), Times.Never, "Sent in the wrong order");
}
[TestMethod]
public async Task TestPublishDomainQueryAsync()
{
var services = new ServiceCollection();
var eventBus = new Mock<IEventBus>();
eventBus.Setup(e => e.PublishAsync(It.IsAny<ProductItemDomainQuery>()))
.Callback<ProductItemDomainQuery>(query =>
{
if (query.ProductId == "2f8d4c3c-1736-4e56-a188-f865da6a63d1")
query.Result = "apple";
});
var integrationEventBus = new Mock<IIntegrationEventBus>();
var uoW = new Mock<IUnitOfWork>();
uoW.Setup(u => u.CommitAsync(default)).Verifiable();
var options = Options.Create(new DispatcherOptions(services) { Assemblies = AppDomain.CurrentDomain.GetAssemblies() });
var domainEventBus = new DomainEventBus(eventBus.Object, integrationEventBus.Object, uoW.Object, options);
var query = new ProductItemDomainQuery() { ProductId = "2f8d4c3c-1736-4e56-a188-f865da6a63d1" };
await domainEventBus.PublishAsync(query);
Assert.IsTrue(query.Result == "apple");
}
[TestMethod]
public async Task TestCommitAsync()
{
var services = new ServiceCollection();
_uoW.Setup(uow => uow.CommitAsync(CancellationToken.None)).Verifiable();
Mock<IOptions<DispatcherOptions>> options = new();
var domainEventBus = new DomainEventBus(_eventBus.Object, _integrationEventBus.Object, _uoW.Object, options.Object);
await domainEventBus.CommitAsync(CancellationToken.None);
_uoW.Verify(u => u.CommitAsync(default), Times.Once, "CommitAsync must be called only once");
}
[TestMethod]
public void TestParameterInitialization()
{
var id = Guid.NewGuid();
var createTime = DateTime.UtcNow;
var domainCommand = new DomainCommand();
Assert.IsTrue(domainCommand.Id != default);
Assert.IsTrue(domainCommand.CreationTime != default && domainCommand.CreationTime >= createTime);
domainCommand = new DomainCommand(id, createTime);
Assert.IsTrue(domainCommand.Id == id);
Assert.IsTrue(domainCommand.CreationTime == createTime);
var domainEvent = new DomainEvent();
Assert.IsTrue(domainEvent.Id != default);
Assert.IsTrue(domainEvent.CreationTime != default && domainEvent.CreationTime >= createTime);
domainEvent = new DomainEvent(id, createTime);
Assert.IsTrue(domainEvent.Id == id);
Assert.IsTrue(domainEvent.CreationTime == createTime);
var domainQuery = new ProductItemDomainQuery()
{
ProductId = Guid.NewGuid().ToString()
};
Assert.IsTrue(domainQuery.Id != default);
Assert.IsTrue(domainQuery.CreationTime != default && domainQuery.CreationTime >= createTime);
}
[TestMethod]
public void TestDomainQueryUnitOfWork()
{
var domainQuery = new ProductItemDomainQuery()
{
ProductId = Guid.NewGuid().ToString()
};
Assert.ThrowsException<NotSupportedException>(() =>
{
domainQuery.UnitOfWork = _uoW.Object;
});
Assert.IsNull(domainQuery.UnitOfWork);
}
[TestMethod]
public async Task TestDomainServiceAsync()
{
_integrationEventBus.Setup(integrationEventBus => integrationEventBus.PublishAsync(It.IsAny<RegisterUserSucceededDomainIntegrationEvent>())).Verifiable();
_services.AddDomainEventBus(options =>
{
options.Assemblies = new Assembly[1] { typeof(DomainEventBusTest).Assembly };
options.Services.AddScoped(serviceProvider => _eventBus.Object);
options.Services.AddScoped(serviceProvider => _integrationEventBus.Object);
options.Services.AddScoped(serviceProvider => _uoW.Object);
});
var serviceProvider = _services.BuildServiceProvider();
var userDomainService = serviceProvider.GetRequiredService<UserDomainService>();
var domainIntegrationEvent = new RegisterUserSucceededDomainIntegrationEvent() { Account = "Tom" };
await userDomainService.RegisterUserSucceededAsync(domainIntegrationEvent);
_integrationEventBus.Verify(integrationEventBus => integrationEventBus.PublishAsync(domainIntegrationEvent), Times.Once);
}
[TestMethod]
public async Task TestPublishEvent()
{
var domainEventBus = new DomainEventBus(_eventBus.Object, _integrationEventBus.Object, _uoW.Object, _dispatcherOptions);
_eventBus.Setup(eventBus => eventBus.PublishAsync(It.IsAny<ForgetPasswordEvent>())).Verifiable();
var @event = new ForgetPasswordEvent()
{
Account = "Tom"
};
await domainEventBus.PublishAsync(@event);
_eventBus.Verify(eventBus => eventBus.PublishAsync(@event), Times.Once);
}
}
| 41.862857 | 173 | 0.676631 | [
"MIT"
] | capdiem/MASA.Contrib | test/Masa.Contrib.Ddd.Domain.Tests/DomainEventBusTest.cs | 14,652 | C# |
using System;
using static Gamer.Core.Debug;
namespace grendgine_collada
{
public partial class Grendgine_Collada_Bool_Array_String
{
public bool[] Value() => Grendgine_Collada_Parse_Utils.String_To_Bool(Value_As_String);
}
public partial class Grendgine_Collada_Common_Float2_Or_Param_Type
{
public float[] Value() => Grendgine_Collada_Parse_Utils.String_To_Float(Value_As_String);
}
public partial class Grendgine_Collada_Float_Array_String
{
public float[] Value() => Grendgine_Collada_Parse_Utils.String_To_Float(Value_As_String);
}
public partial class Grendgine_Collada_Int_Array_String
{
public int[] Value() => Grendgine_Collada_Parse_Utils.String_To_Int(this.Value_As_String);
}
public class Grendgine_Collada_Parse_Utils
{
public static int[] String_To_Int(string int_array)
{
var str = int_array.Split(' ');
var array = new int[str.LongLength];
try
{
for (var i = 0L; i < str.LongLength; i++)
array[i] = Convert.ToInt32(str[i]);
}
catch (Exception e)
{
Log(e.ToString());
Log(int_array);
}
return array;
}
public static float[] String_To_Float(string float_array)
{
var str = float_array.Split(' ');
var array = new float[str.LongLength];
try
{
for (var i = 0L; i < str.LongLength; i++)
array[i] = Convert.ToSingle(str[i]);
}
catch (Exception e)
{
Log(e.ToString());
Log(float_array);
}
return array;
}
public static bool[] String_To_Bool(string bool_array)
{
var str = bool_array.Split(' ');
var array = new bool[str.LongLength];
try
{
for (var i = 0L; i < str.LongLength; i++)
array[i] = Convert.ToBoolean(str[i]);
}
catch (Exception e)
{
Log(e.ToString());
Log(bool_array);
}
return array;
}
}
public partial class Grendgine_Collada_SID_Float_Array_String
{
public float[] Value() => Grendgine_Collada_Parse_Utils.String_To_Float(Value_As_String);
}
public partial class Grendgine_Collada_SID_Int_Array_String
{
public int[] Value() => Grendgine_Collada_Parse_Utils.String_To_Int(Value_As_String);
}
public partial class Grendgine_Collada_String_Array_String
{
public string[] Value() => Value_Pre_Parse.Split(' ');
}
} | 30.723404 | 99 | 0.542936 | [
"MIT"
] | WildGenie/game-estates | src/Formats/Collada/src/Gamer.Format.Collada/Collada/Collada_Helpers.cs | 2,888 | C# |
namespace GraphSharp
{
public class WrappedVertex<TVertex>
{
private TVertex originalVertex;
public TVertex Original
{
get { return originalVertex; }
}
public WrappedVertex(TVertex original)
{
this.originalVertex = original;
}
}
} | 15.9375 | 40 | 0.713725 | [
"Apache-2.0"
] | Cimpress-ACS/Mosaic | ThirdPartyLibs/GraphSharp/src/Graph#/WrappedVertex.cs | 257 | C# |
using System.IO;
using CP77.CR2W.Reflection;
using FastMember;
using static CP77.CR2W.Types.Enums;
namespace CP77.CR2W.Types
{
[REDMeta]
public class animFloatTrackInfo : CVariable
{
[Ordinal(0)] [RED("name")] public CName Name { get; set; }
[Ordinal(1)] [RED("referenceValue")] public CFloat ReferenceValue { get; set; }
public animFloatTrackInfo(CR2WFile cr2w, CVariable parent, string name) : base(cr2w, parent, name) { }
}
}
| 27 | 105 | 0.694989 | [
"MIT"
] | Eingin/CP77Tools | CP77.CR2W/Types/cp77/animFloatTrackInfo.cs | 443 | C# |
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
using System.Collections.Generic;
using Aliyun.Acs.Core;
using Aliyun.Acs.Core.Http;
using Aliyun.Acs.Core.Transform;
using Aliyun.Acs.Core.Utils;
using Aliyun.Acs.alimt.Transform;
using Aliyun.Acs.alimt.Transform.V20181012;
namespace Aliyun.Acs.alimt.Model.V20181012
{
public class CreateImageTranslateTaskRequest : RpcAcsRequest<CreateImageTranslateTaskResponse>
{
public CreateImageTranslateTaskRequest()
: base("alimt", "2018-10-12", "CreateImageTranslateTask", "alimt", "openAPI")
{
if (this.GetType().GetProperty("ProductEndpointMap") != null && this.GetType().GetProperty("ProductEndpointType") != null)
{
this.GetType().GetProperty("ProductEndpointMap").SetValue(this, Aliyun.Acs.alimt.Endpoint.endpointMap, null);
this.GetType().GetProperty("ProductEndpointType").SetValue(this, Aliyun.Acs.alimt.Endpoint.endpointRegionalType, null);
}
Method = MethodType.POST;
}
private string sourceLanguage;
private string clientToken;
private string urlList;
private string extra;
private string targetLanguage;
public string SourceLanguage
{
get
{
return sourceLanguage;
}
set
{
sourceLanguage = value;
DictionaryUtil.Add(BodyParameters, "SourceLanguage", value);
}
}
public string ClientToken
{
get
{
return clientToken;
}
set
{
clientToken = value;
DictionaryUtil.Add(BodyParameters, "ClientToken", value);
}
}
public string UrlList
{
get
{
return urlList;
}
set
{
urlList = value;
DictionaryUtil.Add(BodyParameters, "UrlList", value);
}
}
public string Extra
{
get
{
return extra;
}
set
{
extra = value;
DictionaryUtil.Add(BodyParameters, "Extra", value);
}
}
public string TargetLanguage
{
get
{
return targetLanguage;
}
set
{
targetLanguage = value;
DictionaryUtil.Add(BodyParameters, "TargetLanguage", value);
}
}
public override bool CheckShowJsonItemName()
{
return false;
}
public override CreateImageTranslateTaskResponse GetResponse(UnmarshallerContext unmarshallerContext)
{
return CreateImageTranslateTaskResponseUnmarshaller.Unmarshall(unmarshallerContext);
}
}
}
| 25.116279 | 135 | 0.670679 | [
"Apache-2.0"
] | AxiosCros/aliyun-openapi-net-sdk | aliyun-net-sdk-alimt/Alimt/Model/V20181012/CreateImageTranslateTaskRequest.cs | 3,240 | C# |
using System.ComponentModel;
using TestApp.Models.StarWarsAPI;
using TestApp.ViewModels;
using Xamarin.Forms;
namespace TestApp.Views
{
// Learn more about making custom code visible in the Xamarin.Forms previewer
// by visiting https://aka.ms/xamarinforms-previewer
[DesignTimeVisible(false)]
public partial class ItemDetailPage : ContentPage
{
ItemDetailViewModel viewModel;
public ItemDetailPage(ItemDetailViewModel viewModel)
{
InitializeComponent();
BindingContext = this.viewModel = viewModel;
}
public ItemDetailPage()
{
InitializeComponent();
var item = new Starships
{
//Text = "Item 1",
//Description = "This is an item description."
};
viewModel = new ItemDetailViewModel(item);
BindingContext = viewModel;
}
}
} | 26.055556 | 81 | 0.610874 | [
"MIT"
] | Xablu/Xablu.WebApiClient | src/Samples/TestApp/Views/ItemDetailPage.xaml.cs | 940 | C# |
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Globalization;
#if NETFX_CORE
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
#elif DNXCORE50
using Xunit;
using Test = Xunit.FactAttribute;
using Assert = Newtonsoft.Json.Tests.XUnitAssert;
#else
using NUnit.Framework;
#endif
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Tests.Utilities
{
[TestFixture]
public class ConvertUtilsTests : TestFixtureBase
{
[Test]
public void Int64TryParse()
{
long l;
char[] c = "43443333222211111117".ToCharArray();
ParseResult result = ConvertUtils.Int64TryParse(c, 0, c.Length, out l);
Assert.AreEqual(ParseResult.Overflow, result);
c = "9223372036854775807".ToCharArray();
result = ConvertUtils.Int64TryParse(c, 0, c.Length, out l);
Assert.AreEqual(ParseResult.Success, result);
Assert.AreEqual(9223372036854775807L, l);
c = "9223372036854775808".ToCharArray();
result = ConvertUtils.Int64TryParse(c, 0, c.Length, out l);
Assert.AreEqual(ParseResult.Overflow, result);
for (int i = 3; i < 10; i++)
{
c = ("9" + i + "23372036854775807").ToCharArray();
result = ConvertUtils.Int64TryParse(c, 0, c.Length, out l);
Assert.AreEqual(ParseResult.Overflow, result);
}
c = "-9223372036854775808".ToCharArray();
result = ConvertUtils.Int64TryParse(c, 0, c.Length, out l);
Assert.AreEqual(ParseResult.Success, result);
Assert.AreEqual(-9223372036854775808L, l);
c = "-9223372036854775809".ToCharArray();
result = ConvertUtils.Int64TryParse(c, 0, c.Length, out l);
Assert.AreEqual(ParseResult.Overflow, result);
for (int i = 3; i < 10; i++)
{
c = ("-9" + i + "23372036854775808").ToCharArray();
result = ConvertUtils.Int64TryParse(c, 0, c.Length, out l);
Assert.AreEqual(ParseResult.Overflow, result);
}
}
[Test]
public void Int32TryParse()
{
int i;
char[] c = "43443333227".ToCharArray();
ParseResult result = ConvertUtils.Int32TryParse(c, 0, c.Length, out i);
Assert.AreEqual(ParseResult.Overflow, result);
c = "2147483647".ToCharArray();
result = ConvertUtils.Int32TryParse(c, 0, c.Length, out i);
Assert.AreEqual(ParseResult.Success, result);
Assert.AreEqual(2147483647, i);
c = "2147483648".ToCharArray();
result = ConvertUtils.Int32TryParse(c, 0, c.Length, out i);
Assert.AreEqual(ParseResult.Overflow, result);
c = "-2147483648".ToCharArray();
result = ConvertUtils.Int32TryParse(c, 0, c.Length, out i);
Assert.AreEqual(ParseResult.Success, result);
Assert.AreEqual(-2147483648, i);
c = "-2147483649".ToCharArray();
result = ConvertUtils.Int32TryParse(c, 0, c.Length, out i);
Assert.AreEqual(ParseResult.Overflow, result);
for (int j = 2; j < 10; j++)
{
for (int k = 2; k < 10; k++)
{
string t = j.ToString(CultureInfo.InvariantCulture) + k.ToString(CultureInfo.InvariantCulture) + "47483647";
c = t.ToCharArray();
result = ConvertUtils.Int32TryParse(c, 0, c.Length, out i);
Assert.AreEqual(ParseResult.Overflow, result);
}
}
for (int j = 2; j < 10; j++)
{
for (int k = 2; k < 10; k++)
{
string t = "-" + j.ToString(CultureInfo.InvariantCulture) + k.ToString(CultureInfo.InvariantCulture) + "47483648";
c = t.ToCharArray();
result = ConvertUtils.Int32TryParse(c, 0, c.Length, out i);
Assert.AreEqual(ParseResult.Overflow, result);
}
}
}
}
} | 39.185714 | 134 | 0.610828 | [
"MIT"
] | jkorell/Newtonsoft.Json | Src/Newtonsoft.Json.Tests/Utilities/ConvertUtilsTests.cs | 5,488 | C# |
//
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the MIT License. See LICENSE file in the project root for full license information.
//
using Newtonsoft.Json;
namespace Dnn.AuthServices.Jwt.Components.Entity
{
/// <summary>
/// Structure used for the Login to obtain a Json Web Token (JWT).
/// </summary>
[JsonObject]
public struct LoginData
{
[JsonProperty("u")]
public string Username;
[JsonProperty("p")]
public string Password;
}
}
| 25.142857 | 101 | 0.647727 | [
"MIT"
] | CMarius94/Dnn.Platform | DNN Platform/Dnn.AuthServices.Jwt/Components/Entity/LoginData.cs | 530 | C# |
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated from a template.
//
// Manual changes to this file may cause unexpected behavior in your application.
// Manual changes to this file will be overwritten if the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace OpenItems.Data
{
using System;
using System.Collections.Generic;
public partial class tblFS_CostElementTypes
{
public string COST_ELEM_CD { get; set; }
public string COST_ELEM_DESC { get; set; }
public bool IS_AWARD_CALC { get; set; }
public bool IS_TRAINING_CALC { get; set; }
}
}
| 33.608696 | 85 | 0.532988 | [
"CC0-1.0"
] | gaybro8777/FM-ULO | Archive/OpenItems/Data/tblFS_CostElementTypes.cs | 773 | C# |
using System;
using System.Threading;
namespace OfficeDevPnP.Core.Diagnostics
{
/// <summary>
/// Logging class
/// </summary>
public static class Log
{
[ThreadStatic]
private static ILogger _logger;
[ThreadStatic]
private static LogLevel? _logLevel;
/// <summary>
/// Gets or sets Log Level
/// </summary>
public static LogLevel LogLevel
{
get { return _logLevel.Value; }
set { _logLevel = value; }
}
/// <summary>
/// Gets or sets ILogger object
/// </summary>
public static ILogger Logger
{
get { return _logger; }
set { _logger = value; }
}
public delegate void AddtionalLog(string source, string message);
public delegate void AddtionalErrorLog(string source, string message, Exception ex = null);
public static AddtionalLog AddtionalLogFn { get; set; }
public static AddtionalErrorLog AddtionalErrorLogFn { get; set; }
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters", MessageId = "OfficeDevPnP.Core.Diagnostics.LogEntry.set_Message(System.String)")]
private static void InitializeLogger()
{
if (_logger == null)
{
var config = (OfficeDevPnP.Core.Diagnostics.LogConfigurationTracingSection)System.Configuration.ConfigurationManager.GetSection("pnp/tracing");
if (config != null)
{
_logLevel = config.LogLevel;
try
{
if (config.Logger.ElementInformation.IsPresent)
{
var loggerType = Type.GetType(config.Logger.Type, false);
#if !NETSTANDARD2_0
_logger = (ILogger)Activator.CreateInstance(loggerType.Assembly.FullName, loggerType.FullName).Unwrap();
#else
_logger = (ILogger)Activator.CreateInstance(loggerType);
#endif
}
else
{
_logger = new TraceLogger();
}
}
catch (Exception ex)
{
// Something went wrong, fall back to the built-in PnPTraceLogger
_logger = new TraceLogger();
_logger.Error(
new LogEntry()
{
Exception = ex,
Message = "Logger registration failed. Falling back to TraceLogger.",
EllapsedMilliseconds = 0,
CorrelationId = Guid.Empty,
ThreadId = Thread.CurrentThread.ManagedThreadId,
Source = "PnP"
});
}
}
else
{
// Defaulting to built in logger
if (!_logLevel.HasValue)
{
_logLevel = LogLevel.Debug;
}
_logger = new TraceLogger();
}
}
}
private static bool ShouldLog(LogLevel logLevel)
{
switch (logLevel)
{
case LogLevel.Warning:
return _logLevel == LogLevel.Debug || _logLevel == LogLevel.Information || _logLevel == LogLevel.Warning;
case LogLevel.Information:
return _logLevel == LogLevel.Debug || _logLevel == LogLevel.Information;
case LogLevel.Debug:
return _logLevel == LogLevel.Debug;
default:
return true;
}
}
#region Public Members
public static void AdditionalLog(AddtionalLog delegateFn)
{
AddtionalLogFn = delegateFn;
}
public static void AdditionaErrorlLog(AddtionalErrorLog delegateFn)
{
AddtionalErrorLogFn = delegateFn;
}
#region Error
/// <summary>
/// Logs error message and source
/// </summary>
/// <param name="source">Error source</param>
/// <param name="message">Error message</param>
/// <param name="args">Arguments object</param>
public static void Error(string source, string message, params object[] args)
{
InitializeLogger();
if (ShouldLog(LogLevel.Error))
{
_logger.Error(new LogEntry()
{
Message = string.Format(message, args),
Source = source
});
}
}
/// <summary>
/// Logs error message, source and exception
/// </summary>
/// <param name="ex">Exception object</param>
/// <param name="source">Error source</param>
/// <param name="message">Error message</param>
/// <param name="args">Arguments object</param>
public static void Error(Exception ex, string source, string message, params object[] args)
{
InitializeLogger();
if (ShouldLog(LogLevel.Error))
{
_logger.Error(new LogEntry()
{
Message = string.Format(message, args),
Source = source,
Exception = ex,
});
}
}
/// <summary>
/// Error LogEntry
/// </summary>
/// <param name="logEntry">LogEntry object</param>
public static void Error(LogEntry logEntry)
{
InitializeLogger();
if (ShouldLog(LogLevel.Error))
{
_logger.Error(logEntry);
}
}
#endregion
#region Info
/// <summary>
/// Log Information
/// </summary>
/// <param name="source">Source string</param>
/// <param name="message">Message string</param>
/// <param name="args">Arguments object</param>
public static void Info(string source, string message, params object[] args)
{
InitializeLogger();
if (ShouldLog(LogLevel.Information))
{
_logger.Info(new LogEntry()
{
Message = string.Format(message, args),
Source = source
});
}
}
/// <summary>
/// Log Information
/// </summary>
/// <param name="ex">Exception object</param>
/// <param name="source">Source string</param>
/// <param name="message">Message string</param>
/// <param name="args">Arguments option</param>
public static void Info(Exception ex, string source, string message, params object[] args)
{
InitializeLogger();
if (ShouldLog(LogLevel.Information))
{
_logger.Info(new LogEntry()
{
Message = string.Format(message, args),
Source = source,
Exception = ex,
});
}
}
/// <summary>
/// Log Information
/// </summary>
/// <param name="logEntry">LogEntry object</param>
public static void Info(LogEntry logEntry)
{
InitializeLogger();
if (ShouldLog(LogLevel.Information))
{
_logger.Info(logEntry);
}
}
#endregion
#region Warning
/// <summary>
/// Warning Log
/// </summary>
/// <param name="source">Source string</param>
/// <param name="message">Message string</param>
/// <param name="args">Arguments object</param>
public static void Warning(string source, string message, params object[] args)
{
InitializeLogger();
if (ShouldLog(LogLevel.Warning))
{
_logger.Warning(new LogEntry()
{
Message = string.Format(message, args),
Source = source,
});
}
}
/// <summary>
/// Warning Log
/// </summary>
/// <param name="source">Source string</param>
/// <param name="ex">Exception object</param>
/// <param name="message">Message string</param>
/// <param name="args">Arguments object</param>
public static void Warning(string source, Exception ex, string message, params object[] args)
{
InitializeLogger();
if (ShouldLog(LogLevel.Warning))
{
_logger.Warning(new LogEntry()
{
Message = string.Format(message, args),
Source = source,
Exception = ex,
});
}
}
/// <summary>
/// Warning Log
/// </summary>
/// <param name="logEntry">LogEntry object</param>
public static void Warning(LogEntry logEntry)
{
InitializeLogger();
if (ShouldLog(LogLevel.Warning))
{
_logger.Warning(logEntry);
}
}
#endregion
#region Debug
/// <summary>
/// Debug Log
/// </summary>
/// <param name="source">Source stirng</param>
/// <param name="message">Message string</param>
/// <param name="args">Arguments object</param>
public static void Debug(string source, string message, params object[] args)
{
InitializeLogger();
if (ShouldLog(LogLevel.Debug))
{
_logger.Debug(new LogEntry()
{
Message = string.Format(message, args),
Source = source,
});
}
}
/// <summary>
/// Debug Log
/// </summary>
/// <param name="source">Source string</param>
/// <param name="ex">Exception object</param>
/// <param name="message">Message string</param>
/// <param name="args">Arguments object</param>
public static void Debug(string source, Exception ex, string message, params object[] args)
{
InitializeLogger();
if (ShouldLog(LogLevel.Debug))
{
_logger.Debug(new LogEntry()
{
Message = string.Format(message, args),
Source = source,
Exception = ex,
});
}
}
/// <summary>
/// Debug Log
/// </summary>
/// <param name="logEntry">LogEntry object</param>
public static void Debug(LogEntry logEntry)
{
InitializeLogger();
if (ShouldLog(LogLevel.Debug))
{
_logger.Debug(logEntry);
}
}
#endregion
#endregion
}
} | 33.239067 | 220 | 0.476976 | [
"MIT"
] | Ddv0623/PnP-Sites-Core | Core/OfficeDevPnP.Core/Diagnostics/Log.cs | 11,403 | C# |
//
// System.Diagnostics.OverFlowAction
//
// Authors:
// Gert Driesen ([email protected])
//
// (C) 2006 Novell
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
#if NET_2_0
namespace System.Diagnostics
{
public enum OverflowAction
{
DoNotOverwrite = -1,
OverwriteAsNeeded = 0,
OverwriteOlder = 1
}
}
#endif
| 34.341463 | 74 | 0.727983 | [
"MIT"
] | GrapeCity/pagefx | mono/mcs/class/System/System.Diagnostics/OverflowAction.cs | 1,408 | C# |
// --------------------------------------------------------------------------------------------
// Copyright (c) 2019 The CefNet Authors. All rights reserved.
// Licensed under the MIT license.
// See the licence file in the project root for full license information.
// --------------------------------------------------------------------------------------------
// Generated by CefGen
// Source: include/capi/cef_request_handler_capi.h
// --------------------------------------------------------------------------------------------
// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
// --------------------------------------------------------------------------------------------
#pragma warning disable 0169, 1591, 1573
using System;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using CefNet.WinApi;
namespace CefNet.CApi
{
/// <summary>
/// Implement this structure to handle events related to browser requests. The
/// functions of this structure will be called on the thread indicated.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
public unsafe partial struct cef_request_handler_t
{
/// <summary>
/// Base structure.
/// </summary>
public cef_base_ref_counted_t @base;
/// <summary>
/// int (*)(_cef_request_handler_t* self, _cef_browser_t* browser, _cef_frame_t* frame, _cef_request_t* request, int user_gesture, int is_redirect)*
/// </summary>
public void* on_before_browse;
/// <summary>
/// Called on the UI thread before browser navigation. Return true (1) to
/// cancel the navigation or false (0) to allow the navigation to proceed. The
/// |request| object cannot be modified in this callback.
/// cef_load_handler_t::OnLoadingStateChange will be called twice in all cases.
/// If the navigation is allowed cef_load_handler_t::OnLoadStart and
/// cef_load_handler_t::OnLoadEnd will be called. If the navigation is canceled
/// cef_load_handler_t::OnLoadError will be called with an |errorCode| value of
/// ERR_ABORTED. The |user_gesture| value will be true (1) if the browser
/// navigated via explicit user gesture (e.g. clicking a link) or false (0) if
/// it navigated automatically (e.g. via the DomContentLoaded event).
/// </summary>
[NativeName("on_before_browse")]
[MethodImpl(MethodImplOptions.ForwardRef)]
public unsafe extern int OnBeforeBrowse(cef_browser_t* browser, cef_frame_t* frame, cef_request_t* request, int user_gesture, int is_redirect);
/// <summary>
/// int (*)(_cef_request_handler_t* self, _cef_browser_t* browser, _cef_frame_t* frame, const cef_string_t* target_url, cef_window_open_disposition_t target_disposition, int user_gesture)*
/// </summary>
public void* on_open_urlfrom_tab;
/// <summary>
/// Called on the UI thread before OnBeforeBrowse in certain limited cases
/// where navigating a new or different browser might be desirable. This
/// includes user-initiated navigation that might open in a special way (e.g.
/// links clicked via middle-click or ctrl + left-click) and certain types of
/// cross-origin navigation initiated from the renderer process (e.g.
/// navigating the top-level frame to/from a file URL). The |browser| and
/// |frame| values represent the source of the navigation. The
/// |target_disposition| value indicates where the user intended to navigate
/// the browser based on standard Chromium behaviors (e.g. current tab, new
/// tab, etc). The |user_gesture| value will be true (1) if the browser
/// navigated via explicit user gesture (e.g. clicking a link) or false (0) if
/// it navigated automatically (e.g. via the DomContentLoaded event). Return
/// true (1) to cancel the navigation or false (0) to allow the navigation to
/// proceed in the source browser's top-level frame.
/// </summary>
[NativeName("on_open_urlfrom_tab")]
[MethodImpl(MethodImplOptions.ForwardRef)]
public unsafe extern int OnOpenUrlFromTab(cef_browser_t* browser, cef_frame_t* frame, [Immutable]cef_string_t* target_url, CefWindowOpenDisposition target_disposition, int user_gesture);
/// <summary>
/// _cef_resource_request_handler_t* (*)(_cef_request_handler_t* self, _cef_browser_t* browser, _cef_frame_t* frame, _cef_request_t* request, int is_navigation, int is_download, const cef_string_t* request_initiator, int* disable_default_handling)*
/// </summary>
public void* get_resource_request_handler;
/// <summary>
/// Called on the browser process IO thread before a resource request is
/// initiated. The |browser| and |frame| values represent the source of the
/// request. |request| represents the request contents and cannot be modified
/// in this callback. |is_navigation| will be true (1) if the resource request
/// is a navigation. |is_download| will be true (1) if the resource request is
/// a download. |request_initiator| is the origin (scheme + domain) of the page
/// that initiated the request. Set |disable_default_handling| to true (1) to
/// disable default handling of the request, in which case it will need to be
/// handled via cef_resource_request_handler_t::GetResourceHandler or it will
/// be canceled. To allow the resource load to proceed with default handling
/// return NULL. To specify a handler for the resource return a
/// cef_resource_request_handler_t object. If this callback returns NULL the
/// same function will be called on the associated
/// cef_request_context_handler_t, if any.
/// </summary>
[MethodImpl(MethodImplOptions.ForwardRef)]
[NativeName("get_resource_request_handler")]
public unsafe extern cef_resource_request_handler_t* GetResourceRequestHandler(cef_browser_t* browser, cef_frame_t* frame, cef_request_t* request, int is_navigation, int is_download, [Immutable]cef_string_t* request_initiator, int* disable_default_handling);
/// <summary>
/// int (*)(_cef_request_handler_t* self, _cef_browser_t* browser, const cef_string_t* origin_url, int isProxy, const cef_string_t* host, int port, const cef_string_t* realm, const cef_string_t* scheme, _cef_auth_callback_t* callback)*
/// </summary>
public void* get_auth_credentials;
/// <summary>
/// Called on the IO thread when the browser needs credentials from the user.
/// |origin_url| is the origin making this authentication request. |isProxy|
/// indicates whether the host is a proxy server. |host| contains the hostname
/// and |port| contains the port number. |realm| is the realm of the challenge
/// and may be NULL. |scheme| is the authentication scheme used, such as
/// "basic" or "digest", and will be NULL if the source of the request is an
/// FTP server. Return true (1) to continue the request and call
/// cef_auth_callback_t::cont() either in this function or at a later time when
/// the authentication information is available. Return false (0) to cancel the
/// request immediately.
/// </summary>
[NativeName("get_auth_credentials")]
[MethodImpl(MethodImplOptions.ForwardRef)]
public unsafe extern int GetAuthCredentials(cef_browser_t* browser, [Immutable]cef_string_t* origin_url, int isProxy, [Immutable]cef_string_t* host, int port, [Immutable]cef_string_t* realm, [Immutable]cef_string_t* scheme, cef_auth_callback_t* callback);
/// <summary>
/// int (*)(_cef_request_handler_t* self, _cef_browser_t* browser, const cef_string_t* origin_url, int64 new_size, _cef_request_callback_t* callback)*
/// </summary>
public void* on_quota_request;
/// <summary>
/// Called on the IO thread when JavaScript requests a specific storage quota
/// size via the webkitStorageInfo.requestQuota function. |origin_url| is the
/// origin of the page making the request. |new_size| is the requested quota
/// size in bytes. Return true (1) to continue the request and call
/// cef_request_callback_t::cont() either in this function or at a later time
/// to grant or deny the request. Return false (0) to cancel the request
/// immediately.
/// </summary>
[NativeName("on_quota_request")]
[MethodImpl(MethodImplOptions.ForwardRef)]
public unsafe extern int OnQuotaRequest(cef_browser_t* browser, [Immutable]cef_string_t* origin_url, long new_size, cef_request_callback_t* callback);
/// <summary>
/// int (*)(_cef_request_handler_t* self, _cef_browser_t* browser, cef_errorcode_t cert_error, const cef_string_t* request_url, _cef_sslinfo_t* ssl_info, _cef_request_callback_t* callback)*
/// </summary>
public void* on_certificate_error;
/// <summary>
/// Called on the UI thread to handle requests for URLs with an invalid SSL
/// certificate. Return true (1) and call cef_request_callback_t::cont() either
/// in this function or at a later time to continue or cancel the request.
/// Return false (0) to cancel the request immediately. If
/// CefSettings.ignore_certificate_errors is set all invalid certificates will
/// be accepted without calling this function.
/// </summary>
[NativeName("on_certificate_error")]
[MethodImpl(MethodImplOptions.ForwardRef)]
public unsafe extern int OnCertificateError(cef_browser_t* browser, CefErrorCode cert_error, [Immutable]cef_string_t* request_url, cef_sslinfo_t* ssl_info, cef_request_callback_t* callback);
/// <summary>
/// int (*)(_cef_request_handler_t* self, _cef_browser_t* browser, int isProxy, const cef_string_t* host, int port, size_t certificatesCount, const _cef_x509certificate_t** certificates, _cef_select_client_certificate_callback_t* callback)*
/// </summary>
public void* on_select_client_certificate;
/// <summary>
/// Called on the UI thread when a client certificate is being requested for
/// authentication. Return false (0) to use the default behavior and
/// automatically select the first certificate available. Return true (1) and
/// call cef_select_client_certificate_callback_t::Select either in this
/// function or at a later time to select a certificate. Do not call Select or
/// call it with NULL to continue without using any certificate. |isProxy|
/// indicates whether the host is an HTTPS proxy or the origin server. |host|
/// and |port| contains the hostname and port of the SSL server. |certificates|
/// is the list of certificates to choose from; this list has already been
/// pruned by Chromium so that it only contains certificates from issuers that
/// the server trusts.
/// </summary>
[MethodImpl(MethodImplOptions.ForwardRef)]
[NativeName("on_select_client_certificate")]
public unsafe extern int OnSelectClientCertificate(cef_browser_t* browser, int isProxy, [Immutable]cef_string_t* host, int port, UIntPtr certificatesCount, [Immutable]cef_x509certificate_t** certificates, cef_select_client_certificate_callback_t* callback);
/// <summary>
/// void (*)(_cef_request_handler_t* self, _cef_browser_t* browser, const cef_string_t* plugin_path)*
/// </summary>
public void* on_plugin_crashed;
/// <summary>
/// Called on the browser process UI thread when a plugin has crashed.
/// |plugin_path| is the path of the plugin that crashed.
/// </summary>
[NativeName("on_plugin_crashed")]
[MethodImpl(MethodImplOptions.ForwardRef)]
public unsafe extern void OnPluginCrashed(cef_browser_t* browser, [Immutable]cef_string_t* plugin_path);
/// <summary>
/// void (*)(_cef_request_handler_t* self, _cef_browser_t* browser)*
/// </summary>
public void* on_render_view_ready;
/// <summary>
/// Called on the browser process UI thread when the render view associated
/// with |browser| is ready to receive/handle IPC messages in the render
/// process.
/// </summary>
[NativeName("on_render_view_ready")]
[MethodImpl(MethodImplOptions.ForwardRef)]
public unsafe extern void OnRenderViewReady(cef_browser_t* browser);
/// <summary>
/// void (*)(_cef_request_handler_t* self, _cef_browser_t* browser, cef_termination_status_t status)*
/// </summary>
public void* on_render_process_terminated;
/// <summary>
/// Called on the browser process UI thread when the render process terminates
/// unexpectedly. |status| indicates how the process terminated.
/// </summary>
[MethodImpl(MethodImplOptions.ForwardRef)]
[NativeName("on_render_process_terminated")]
public unsafe extern void OnRenderProcessTerminated(cef_browser_t* browser, CefTerminationStatus status);
}
}
| 55.236607 | 260 | 0.728279 | [
"MIT"
] | bakingam1983/CefNet | CefNet/Generated/Native/Types/cef_request_handler_t.cs | 12,377 | C# |
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using System.Reflection;
using System.Runtime.CompilerServices;
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
[assembly: AssemblyTitle("Microsoft.AppCenter.Distribute")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("Microsoft Corp. All rights reserved.")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("0.0.0.0")]
[assembly: AssemblyFileVersion("4.5.1.0")]
[assembly: AssemblyInformationalVersion("4.5.1-SNAPSHOT")]
[assembly: InternalsVisibleTo("Microsoft.AppCenter.Test.Functional, PublicKey=002400000480000094000000060200000024000052534131000400000100010055c4e2f76a6f3430448b1fd5b9ced790181e698a86759ece168bd955efc4297c9f89a303204019a9d2e8e92d204ba87e4825b36f8ba08113dc7297dcebe3d2bc15fabeae1d8c71d69769adedbc37ba7e197efc537cac2d477772ab38c4d4ccee45ddf99ce4343e9b665b663280c4dae2520b508bc7de0faf1978934f094d68e3")] | 47.5 | 401 | 0.8 | [
"MIT"
] | BeyondDimension/appcenter-sdk-dotnet | SDK/AppCenterDistribute/Microsoft.AppCenter.Distribute.iOS/Properties/AssemblyInfo.cs | 1,520 | C# |
using System.IO;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Serilog;
using Serilog.Events;
namespace Acme.BookStore.DbMigrator
{
class Program
{
static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Information()
.MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
.MinimumLevel.Override("Volo.Abp", LogEventLevel.Warning)
#if DEBUG
.MinimumLevel.Override("Acme.BookStore", LogEventLevel.Debug)
#else
.MinimumLevel.Override("Acme.BookStore", LogEventLevel.Information)
#endif
.Enrich.FromLogContext()
.WriteTo.Async(c => c.File("Logs/logs.txt"))
.WriteTo.Async(c => c.Console())
.CreateLogger();
await CreateHostBuilder(args).RunConsoleAsync();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureLogging((context, logging) => logging.ClearProviders())
.ConfigureServices((hostContext, services) =>
{
services.AddHostedService<DbMigratorHostedService>();
});
}
}
| 33.853659 | 83 | 0.616715 | [
"MIT"
] | 271943794/abp-samples | BookStore-Blazor-EfCore/src/Acme.BookStore.DbMigrator/Program.cs | 1,388 | C# |
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
#nullable disable
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Test.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Recommendations
{
public class LockKeywordRecommenderTests : KeywordRecommenderTests
{
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestAtRoot_Interactive()
{
await VerifyKeywordAsync(SourceCodeKind.Script,
@"$$");
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestAfterClass_Interactive()
{
await VerifyKeywordAsync(SourceCodeKind.Script,
@"class C { }
$$");
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestAfterGlobalStatement_Interactive()
{
await VerifyKeywordAsync(SourceCodeKind.Script,
@"System.Console.WriteLine();
$$");
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestAfterGlobalVariableDeclaration_Interactive()
{
await VerifyKeywordAsync(SourceCodeKind.Script,
@"int i = 0;
$$");
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestNotInUsingAlias()
{
await VerifyAbsenceAsync(
@"using Goo = $$");
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestNotInGlobalUsingAlias()
{
await VerifyAbsenceAsync(
@"global using Goo = $$");
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestEmptyStatement()
{
await VerifyKeywordAsync(AddInsideMethod(
@"$$"));
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestBeforeStatement()
{
await VerifyKeywordAsync(AddInsideMethod(
@"$$
return true;"));
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestAfterStatement()
{
await VerifyKeywordAsync(AddInsideMethod(
@"return true;
$$"));
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestAfterBlock()
{
await VerifyKeywordAsync(AddInsideMethod(
@"if (true) {
}
$$"));
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestInsideSwitchBlock()
{
await VerifyKeywordAsync(AddInsideMethod(
@"switch (E) {
case 0:
$$"));
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestNotAfterLock1()
{
await VerifyAbsenceAsync(AddInsideMethod(
@"lock $$"));
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestNotAfterLock2()
{
await VerifyAbsenceAsync(AddInsideMethod(
@"lock ($$"));
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestNotAfterLock3()
{
await VerifyAbsenceAsync(AddInsideMethod(
@"lock (l$$"));
}
[Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
public async Task TestNotInClass()
{
await VerifyAbsenceAsync(@"class C
{
$$
}");
}
}
}
| 28.560606 | 74 | 0.638727 | [
"MIT"
] | 333fred/roslyn | src/EditorFeatures/CSharpTest2/Recommendations/LockKeywordRecommenderTests.cs | 3,772 | C# |
using System.Reflection;
namespace Xunit.Abstractions
{
/// <summary>
/// Represents a reflection-backed implementation of <see cref="IAssemblyInfo"/>.
/// </summary>
public interface IReflectionAssemblyInfo : IAssemblyInfo
{
/// <summary>
/// Gets the underlying <see cref="Assembly"/> for the assembly.
/// </summary>
Assembly Assembly { get; }
}
}
| 22.875 | 82 | 0.693989 | [
"Apache-2.0"
] | 0xced/xunit | src/xunit.v3.abstractions/Reflection/IReflectionAssemblyInfo.cs | 366 | C# |
// *** WARNING: this file was generated by the Pulumi SDK Generator. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Pulumi.Serialization;
namespace Pulumi.AzureNextGen.CognitiveServices.Latest
{
/// <summary>
/// Cognitive Services Account is an Azure resource representing the provisioned account, its type, location and SKU.
/// Latest API Version: 2017-04-18.
/// </summary>
[Obsolete(@"The 'latest' version is deprecated. Please migrate to the resource in the top-level module: 'azure-nextgen:cognitiveservices:Account'.")]
[AzureNextGenResourceType("azure-nextgen:cognitiveservices/latest:Account")]
public partial class Account : Pulumi.CustomResource
{
/// <summary>
/// Entity Tag
/// </summary>
[Output("etag")]
public Output<string> Etag { get; private set; } = null!;
/// <summary>
/// The identity of Cognitive Services account.
/// </summary>
[Output("identity")]
public Output<Outputs.IdentityResponse?> Identity { get; private set; } = null!;
/// <summary>
/// The Kind of the resource.
/// </summary>
[Output("kind")]
public Output<string?> Kind { get; private set; } = null!;
/// <summary>
/// The location of the resource
/// </summary>
[Output("location")]
public Output<string?> Location { get; private set; } = null!;
/// <summary>
/// The name of the created account
/// </summary>
[Output("name")]
public Output<string> Name { get; private set; } = null!;
/// <summary>
/// Properties of Cognitive Services account.
/// </summary>
[Output("properties")]
public Output<Outputs.CognitiveServicesAccountPropertiesResponse> Properties { get; private set; } = null!;
/// <summary>
/// The SKU of Cognitive Services account.
/// </summary>
[Output("sku")]
public Output<Outputs.SkuResponse?> Sku { get; private set; } = null!;
/// <summary>
/// Gets or sets a list of key value pairs that describe the resource. These tags can be used in viewing and grouping this resource (across resource groups). A maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128 characters and value no greater than 256 characters.
/// </summary>
[Output("tags")]
public Output<ImmutableDictionary<string, string>?> Tags { get; private set; } = null!;
/// <summary>
/// Resource type
/// </summary>
[Output("type")]
public Output<string> Type { get; private set; } = null!;
/// <summary>
/// Create a Account resource with the given unique name, arguments, and options.
/// </summary>
///
/// <param name="name">The unique name of the resource</param>
/// <param name="args">The arguments used to populate this resource's properties</param>
/// <param name="options">A bag of options that control this resource's behavior</param>
public Account(string name, AccountArgs args, CustomResourceOptions? options = null)
: base("azure-nextgen:cognitiveservices/latest:Account", name, args ?? new AccountArgs(), MakeResourceOptions(options, ""))
{
}
private Account(string name, Input<string> id, CustomResourceOptions? options = null)
: base("azure-nextgen:cognitiveservices/latest:Account", name, null, MakeResourceOptions(options, id))
{
}
private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input<string>? id)
{
var defaultOptions = new CustomResourceOptions
{
Version = Utilities.Version,
Aliases =
{
new Pulumi.Alias { Type = "azure-nextgen:cognitiveservices:Account"},
new Pulumi.Alias { Type = "azure-nextgen:cognitiveservices/v20160201preview:Account"},
new Pulumi.Alias { Type = "azure-nextgen:cognitiveservices/v20170418:Account"},
},
};
var merged = CustomResourceOptions.Merge(defaultOptions, options);
// Override the ID if one was specified for consistency with other language SDKs.
merged.Id = id ?? merged.Id;
return merged;
}
/// <summary>
/// Get an existing Account resource's state with the given name, ID, and optional extra
/// properties used to qualify the lookup.
/// </summary>
///
/// <param name="name">The unique name of the resulting resource.</param>
/// <param name="id">The unique provider ID of the resource to lookup.</param>
/// <param name="options">A bag of options that control this resource's behavior</param>
public static Account Get(string name, Input<string> id, CustomResourceOptions? options = null)
{
return new Account(name, id, options);
}
}
public sealed class AccountArgs : Pulumi.ResourceArgs
{
/// <summary>
/// The name of Cognitive Services account.
/// </summary>
[Input("accountName")]
public Input<string>? AccountName { get; set; }
/// <summary>
/// The identity of Cognitive Services account.
/// </summary>
[Input("identity")]
public Input<Inputs.IdentityArgs>? Identity { get; set; }
/// <summary>
/// The Kind of the resource.
/// </summary>
[Input("kind")]
public Input<string>? Kind { get; set; }
/// <summary>
/// The location of the resource
/// </summary>
[Input("location")]
public Input<string>? Location { get; set; }
/// <summary>
/// Properties of Cognitive Services account.
/// </summary>
[Input("properties")]
public Input<Inputs.CognitiveServicesAccountPropertiesArgs>? Properties { get; set; }
/// <summary>
/// The name of the resource group. The name is case insensitive.
/// </summary>
[Input("resourceGroupName", required: true)]
public Input<string> ResourceGroupName { get; set; } = null!;
/// <summary>
/// The SKU of Cognitive Services account.
/// </summary>
[Input("sku")]
public Input<Inputs.SkuArgs>? Sku { get; set; }
[Input("tags")]
private InputMap<string>? _tags;
/// <summary>
/// Gets or sets a list of key value pairs that describe the resource. These tags can be used in viewing and grouping this resource (across resource groups). A maximum of 15 tags can be provided for a resource. Each tag must have a key no greater than 128 characters and value no greater than 256 characters.
/// </summary>
public InputMap<string> Tags
{
get => _tags ?? (_tags = new InputMap<string>());
set => _tags = value;
}
public AccountArgs()
{
}
}
}
| 39.88587 | 316 | 0.595994 | [
"Apache-2.0"
] | pulumi/pulumi-azure-nextgen | sdk/dotnet/CognitiveServices/Latest/Account.cs | 7,339 | C# |
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Principal;
using NuGet.Services.Entities;
using NuGet.Versioning;
using NuGetGallery;
namespace GitHubVulnerabilities2Db.Gallery
{
/// <remarks>
/// This job should not attempt to emit any telemetry.
/// </remarks>
public class ThrowingTelemetryService : ITelemetryService
{
public void TraceException(Exception exception)
{
throw new NotImplementedException();
}
public void TrackABTestEnrollmentInitialized(int schemaVersion, int previewSearchBucket, int packageDepentsBucket)
{
throw new NotImplementedException();
}
public void TrackABTestEnrollmentUpgraded(int oldSchemaVersion, int newSchemaVersion, int previewSearchBucket, int packageDepentsBucket)
{
throw new NotImplementedException();
}
public void TrackABTestEvaluated(string name, bool isActive, bool isAuthenticated, int testBucket, int testPercentage)
{
throw new NotImplementedException();
}
public void TrackAccountDeletionCompleted(User deletedUser, User deletedBy, bool success)
{
throw new NotImplementedException();
}
public void TrackCertificateActivated(string thumbprint)
{
throw new NotImplementedException();
}
public void TrackCertificateAdded(string thumbprint)
{
throw new NotImplementedException();
}
public void TrackCertificateDeactivated(string thumbprint)
{
throw new NotImplementedException();
}
public void TrackCreatePackageVerificationKeyEvent(string packageId, string packageVersion, User user, IIdentity identity)
{
throw new NotImplementedException();
}
public void TrackDownloadCountDecreasedDuringRefresh(string packageId, string packageVersion, long oldCount, long newCount)
{
throw new NotImplementedException();
}
public void TrackDownloadJsonRefreshDuration(long milliseconds)
{
throw new NotImplementedException();
}
public void TrackException(Exception exception, Action<Dictionary<string, string>> addProperties)
{
throw new NotImplementedException();
}
public void TrackGetPackageDownloadCountFailed(string packageId, string packageVersion)
{
throw new NotImplementedException();
}
public void TrackGetPackageRegistrationDownloadCountFailed(string packageId)
{
throw new NotImplementedException();
}
public void TrackInvalidLicenseMetadata(string licenseValue)
{
throw new NotImplementedException();
}
public void TrackLicenseFileRejected()
{
throw new NotImplementedException();
}
public void TrackLicenseValidationFailure()
{
throw new NotImplementedException();
}
public void TrackMetricForSearchCircuitBreakerOnBreak(string searchName, Exception exception, HttpResponseMessage responseMessage, string correlationId, string uri)
{
throw new NotImplementedException();
}
public void TrackMetricForSearchCircuitBreakerOnReset(string searchName, string correlationId, string uri)
{
throw new NotImplementedException();
}
public void TrackMetricForSearchExecutionDuration(string url, TimeSpan duration, bool success)
{
throw new NotImplementedException();
}
public void TrackMetricForSearchOnRetry(string searchName, Exception exception, string correlationId, string uri, string circuitBreakerStatus)
{
throw new NotImplementedException();
}
public void TrackMetricForSearchOnTimeout(string searchName, string correlationId, string uri, string circuitBreakerStatus)
{
throw new NotImplementedException();
}
public void TrackMetricForTyposquattingAlgorithmProcessingTime(string packageId, TimeSpan algorithmProcessingTime)
{
throw new NotImplementedException();
}
public void TrackMetricForTyposquattingChecklistRetrievalTime(string packageId, TimeSpan checklistRetrievalTime)
{
throw new NotImplementedException();
}
public void TrackMetricForTyposquattingCheckResultAndTotalTime(string packageId, TimeSpan totalTime, bool wasUploadBlocked, List<string> collisionPackageIds, int checkListLength, TimeSpan checkListCacheExpireTime)
{
throw new NotImplementedException();
}
public void TrackMetricForTyposquattingOwnersCheckTime(string packageId, TimeSpan ownersCheckTime)
{
throw new NotImplementedException();
}
public void TrackNewCredentialCreated(User user, Credential credential)
{
throw new NotImplementedException();
}
public void TrackNewUserRegistrationEvent(User user, Credential identity)
{
throw new NotImplementedException();
}
public void TrackNonFsfOsiLicenseUse(string licenseExpression)
{
throw new NotImplementedException();
}
public void TrackODataCustomQuery(bool? customQuery)
{
throw new NotImplementedException();
}
public void TrackODataQueryFilterEvent(string callContext, bool isEnabled, bool isAllowed, string queryPattern)
{
throw new NotImplementedException();
}
public void TrackOrganizationAdded(Organization organization)
{
throw new NotImplementedException();
}
public void TrackOrganizationTransformCancelled(User user)
{
throw new NotImplementedException();
}
public void TrackOrganizationTransformCompleted(User user)
{
throw new NotImplementedException();
}
public void TrackOrganizationTransformDeclined(User user)
{
throw new NotImplementedException();
}
public void TrackOrganizationTransformInitiated(User user)
{
throw new NotImplementedException();
}
public void TrackPackageDelete(Package package, bool isHardDelete)
{
throw new NotImplementedException();
}
public void TrackPackageDeprecate(IReadOnlyList<Package> packages, PackageDeprecationStatus status, PackageRegistration alternateRegistration, Package alternatePackage, bool hasCustomMessage)
{
throw new NotImplementedException();
}
public void TrackPackageDownloadCountDecreasedFromGallery(string packageId, string packageVersion, long galleryCount, long jsonCount)
{
throw new NotImplementedException();
}
public void TrackPackageHardDeleteReflow(string packageId, string packageVersion)
{
throw new NotImplementedException();
}
public void TrackPackageListed(Package package)
{
throw new NotImplementedException();
}
public void TrackPackageMetadataComplianceError(string packageId, string packageVersion, IEnumerable<string> complianceFailures)
{
throw new NotImplementedException();
}
public void TrackPackageMetadataComplianceWarning(string packageId, string packageVersion, IEnumerable<string> complianceWarnings)
{
throw new NotImplementedException();
}
public void TrackPackageOwnershipAutomaticallyAdded(string packageId, string packageVersion)
{
throw new NotImplementedException();
}
public void TrackPackagePushDisconnectEvent()
{
throw new NotImplementedException();
}
public void TrackPackagePushEvent(Package package, User user, IIdentity identity)
{
throw new NotImplementedException();
}
public void TrackPackagePushFailureEvent(string id, NuGetVersion version)
{
throw new NotImplementedException();
}
public void TrackPackagePushNamespaceConflictEvent(string packageId, string packageVersion, User user, IIdentity identity)
{
throw new NotImplementedException();
}
public void TrackPackagePushOwnerlessNamespaceConflictEvent(string packageId, string packageVersion, User user, IIdentity identity)
{
throw new NotImplementedException();
}
public void TrackPackageReadMeChangeEvent(Package package, string readMeSourceType, PackageEditReadMeState readMeState)
{
throw new NotImplementedException();
}
public void TrackPackageReflow(Package package)
{
throw new NotImplementedException();
}
public void TrackPackageRegistrationDownloadCountDecreasedFromGallery(string packageId, long galleryCount, long jsonCount)
{
throw new NotImplementedException();
}
public void TrackPackageReupload(Package package)
{
throw new NotImplementedException();
}
public void TrackPackageRevalidate(Package package)
{
throw new NotImplementedException();
}
public void TrackPackageUnlisted(Package package)
{
throw new NotImplementedException();
}
public void TrackRequestForAccountDeletion(User user)
{
throw new NotImplementedException();
}
public void TrackRequiredSignerSet(string packageId)
{
throw new NotImplementedException();
}
public void TrackSearchSideBySide(string searchTerm, bool oldSuccess, int oldHits, bool newSuccess, int newHits)
{
throw new NotImplementedException();
}
public void TrackSearchSideBySideFeedback(string searchTerm, int oldHits, int newHits, string betterSide, string mostRelevantPackage, string expectedPackages, bool hasComments, bool hasEmailAddress)
{
throw new NotImplementedException();
}
public void TrackSendEmail(string smtpUri, DateTimeOffset startTime, TimeSpan duration, bool success, int attemptNumber)
{
throw new NotImplementedException();
}
public void TrackSymbolPackageDeleteEvent(string packageId, string packageVersion)
{
throw new NotImplementedException();
}
public void TrackSymbolPackageFailedGalleryValidationEvent(string packageId, string packageVersion)
{
throw new NotImplementedException();
}
public void TrackSymbolPackagePushDisconnectEvent()
{
throw new NotImplementedException();
}
public void TrackSymbolPackagePushEvent(string packageId, string packageVersion)
{
throw new NotImplementedException();
}
public void TrackSymbolPackagePushFailureEvent(string packageId, string packageVersion)
{
throw new NotImplementedException();
}
public void TrackSymbolPackageRevalidate(string packageId, string packageVersion)
{
throw new NotImplementedException();
}
public void TrackUserChangedMultiFactorAuthentication(User user, bool enabledMultiFactorAuth, string referrer)
{
throw new NotImplementedException();
}
public void TrackUserLogin(User user, Credential credential, bool wasMultiFactorAuthenticated)
{
throw new NotImplementedException();
}
public void TrackUserPackageDeleteChecked(UserPackageDeleteEvent details, UserPackageDeleteOutcome outcome)
{
throw new NotImplementedException();
}
public void TrackUserPackageDeleteExecuted(int packageKey, string packageId, string packageVersion, ReportPackageReason reason, bool success)
{
throw new NotImplementedException();
}
public void TrackVerifyPackageKeyEvent(string packageId, string packageVersion, User user, IIdentity identity, int statusCode)
{
throw new NotImplementedException();
}
}
} | 34.034759 | 221 | 0.667295 | [
"Apache-2.0"
] | Mu-L/NuGetGallery | src/GitHubVulnerabilities2Db/Gallery/ThrowingTelemetryService.cs | 12,731 | C# |
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the MIT license. See License.txt in the project root for license information.
#nullable disable
using System;
using Microsoft.VisualStudio.Shell.Interop;
namespace Microsoft.VisualStudio.Editor.Razor.Documents
{
internal class RunningDocumentTableEventSink : IVsRunningDocTableEvents3
{
private readonly VisualStudioEditorDocumentManager _documentManager;
public RunningDocumentTableEventSink(VisualStudioEditorDocumentManager documentManager!!)
{
_documentManager = documentManager;
}
public int OnAfterAttributeChangeEx(uint docCookie, uint grfAttribs, IVsHierarchy pHierOld, uint itemidOld, string pszMkDocumentOld, IVsHierarchy pHierNew, uint itemidNew, string pszMkDocumentNew)
{
// Document has been initialized.
if ((grfAttribs & (uint)__VSRDTATTRIB3.RDTA_DocumentInitialized) != 0)
{
_documentManager.DocumentOpened(docCookie);
}
if ((grfAttribs & (uint)__VSRDTATTRIB.RDTA_MkDocument) != 0)
{
_documentManager.DocumentRenamed(docCookie, pszMkDocumentOld, pszMkDocumentNew);
}
return VSConstants.S_OK;
}
public int OnBeforeLastDocumentUnlock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining, uint dwEditLocksRemaining)
{
// Document is being closed
if (dwReadLocksRemaining + dwEditLocksRemaining == 0)
{
_documentManager.DocumentClosed(docCookie);
}
return VSConstants.S_OK;
}
public int OnBeforeSave(uint docCookie) => VSConstants.S_OK;
public int OnAfterSave(uint docCookie) => VSConstants.S_OK;
public int OnAfterAttributeChange(uint docCookie, uint grfAttribs) => VSConstants.S_OK;
public int OnBeforeDocumentWindowShow(uint docCookie, int fFirstShow, IVsWindowFrame pFrame) => VSConstants.S_OK;
public int OnAfterDocumentWindowHide(uint docCookie, IVsWindowFrame pFrame) => VSConstants.S_OK;
public int OnAfterFirstDocumentLock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining, uint dwEditLocksRemaining) => VSConstants.S_OK;
}
}
| 38.566667 | 204 | 0.697494 | [
"MIT"
] | adrianwright109/razor-tooling | src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Documents/RunningDocumentTableEventSink.cs | 2,316 | C# |
using LiveCharts;
using LiveCharts.Wpf;
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Shapes;
namespace LiveChartTutorial
{
class ViewModel
{
private ChartValues<int> series;
public ChartValues<int> Series
{
get
{
if (series == null)
{
series = GetSeries();
}
return series;
}
}
private ChartValues<int> stacked1;
public ChartValues<int> Stacked1
{
get
{
if (stacked1 == null)
{
stacked1 = new ChartValues<int> { 0, 533, 570, 381, 0, 122, 125, 122, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
}
return stacked1;
}
}
private ChartValues<double> stacked2;
public ChartValues<double> Stacked2
{
get
{
if (stacked2 == null)
{
stacked2 = new ChartValues<double> { 0.0, 0.0, 0.0, 0.0, 78.9, 78.9, 78.9, 78.9, 78.9, 78.9, 78.9, 78.9, 78.9, 0.0, 0.0, 0.0, 0.0, 0.0 };
}
return stacked2;
}
}
private ChartValues<double> stacked3;
public ChartValues<double> Stacked3
{
get
{
if (stacked3 == null)
{
stacked3 = new ChartValues<double> { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 28.0, 167.0, 84.0, 0.0, 0.0, 0.0 };
}
return stacked3;
}
}
ChartValues<int> GetSeries()
{
ChartValues<int> series = new ChartValues<int> { 0, -534, -570, -381, 497, 506, 396, 408, 544, 555, 580, 469, -167, -84, 0, 0, 0, 0 };
return series;
}
}
}
| 23.835294 | 157 | 0.440276 | [
"MIT"
] | pally-ds/ResTool | LiveChartTutorial/ViewModel.cs | 2,028 | C# |
using ArcGIS.Desktop.Framework.Controls;
namespace CoordinateConversionLibrary.Views
{
/// <summary>
/// Interaction logic for ProSelectCoordinateFieldsView.xaml
/// </summary>
public partial class ProSelectCoordinateFieldsView : ProWindow
{
public ProSelectCoordinateFieldsView()
{
InitializeComponent();
}
}
}
| 24.25 | 67 | 0.649485 | [
"Apache-2.0"
] | ArcGIS/coordinate-tool-addin-dotnet | source/CoordinateConversion/ProAppCoordConversionModule/Views/ProSelectCoordinateFieldsView.xaml.cs | 388 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace Diploms.Dto
{
public class TemplateEditDto
{
public int Id { get; set; }
public string Name { get; set; }
public string Type { get; set; }
public string TemplateType { get; set; }
public string FileName { get; set; }
public bool IsDefault {get;set;}
}
}
| 23.444444 | 48 | 0.632701 | [
"MIT"
] | denismaster/dcs | src/Diploms.Dto/Templates/TemplateListItem.cs | 422 | C# |
using System.Threading.Tasks;
namespace EventDriven.CQRS.Tests.Fakes
{
public class FakeEventBus : EventBus.Abstractions.EventBus
{
public override Task PublishAsync<TIntegrationEvent>(
TIntegrationEvent @event,
string topic = null,
string prefix = null)
{
var topicName = topic ?? @event.GetType().Name;
if (!Topics.TryGetValue(topicName, out var handlers))
return Task.CompletedTask;
foreach (var handler in handlers)
handler.HandleAsync(@event);
return Task.CompletedTask;
}
}
} | 31.7 | 65 | 0.600946 | [
"MIT"
] | event-driven-dotnet/EventDriven.CQRS | test/EventDriven.CQRS.Tests/Fakes/FakeEventBus.cs | 634 | C# |
//
// Copyright (c) 2004-2021 Jaroslaw Kowalski <[email protected]>, Kim Christensen, Julian Verdurmen
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * Neither the name of Jaroslaw Kowalski nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
//
#if !SILVERLIGHT && !NETSTANDARD1_3
namespace NLog.Targets
{
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
/// <summary>
/// Controls the text and color formatting for <see cref="ColoredConsoleTarget"/>
/// </summary>
internal interface IColoredConsolePrinter
{
/// <summary>
/// Creates a TextWriter for the console to start building a colored text message
/// </summary>
/// <param name="consoleStream">Active console stream</param>
/// <param name="reusableBuilder">Optional StringBuilder to optimize performance</param>
/// <returns>TextWriter for the console</returns>
TextWriter AcquireTextWriter(TextWriter consoleStream, StringBuilder reusableBuilder);
/// <summary>
/// Releases the TextWriter for the console after having built a colored text message (Restores console colors)
/// </summary>
/// <param name="consoleWriter">Colored TextWriter</param>
/// <param name="consoleStream">Active console stream</param>
/// <param name="oldForegroundColor">Original foreground color for console (If changed)</param>
/// <param name="oldBackgroundColor">Original background color for console (If changed)</param>
/// <param name="flush">Flush TextWriter</param>
void ReleaseTextWriter(TextWriter consoleWriter, TextWriter consoleStream, ConsoleColor? oldForegroundColor, ConsoleColor? oldBackgroundColor, bool flush);
/// <summary>
/// Changes foreground color for the Colored TextWriter
/// </summary>
/// <param name="consoleWriter">Colored TextWriter</param>
/// <param name="foregroundColor">New foreground color for the console</param>
/// <param name="oldForegroundColor">Old previous backgroundColor color for the console</param>
/// <returns>Old foreground color for the console</returns>
ConsoleColor? ChangeForegroundColor(TextWriter consoleWriter, ConsoleColor? foregroundColor, ConsoleColor? oldForegroundColor = null);
/// <summary>
/// Changes backgroundColor color for the Colored TextWriter
/// </summary>
/// <param name="consoleWriter">Colored TextWriter</param>
/// <param name="backgroundColor">New backgroundColor color for the console</param>
/// <param name="oldBackgroundColor">Old previous backgroundColor color for the console</param>
/// <returns>Old backgroundColor color for the console</returns>
ConsoleColor? ChangeBackgroundColor(TextWriter consoleWriter, ConsoleColor? backgroundColor, ConsoleColor? oldBackgroundColor = null);
/// <summary>
/// Restores console colors back to their original state
/// </summary>
/// <param name="consoleWriter">Colored TextWriter</param>
/// <param name="foregroundColor">Original foregroundColor color for the console</param>
/// <param name="backgroundColor">Original backgroundColor color for the console</param>
void ResetDefaultColors(TextWriter consoleWriter, ConsoleColor? foregroundColor, ConsoleColor? backgroundColor);
/// <summary>
/// Writes multiple characters to console in one operation (faster)
/// </summary>
/// <param name="consoleWriter">Colored TextWriter</param>
/// <param name="text">Output Text</param>
/// <param name="index">Start Index</param>
/// <param name="endIndex">End Index</param>
void WriteSubString(TextWriter consoleWriter, string text, int index, int endIndex);
/// <summary>
/// Writes single character to console
/// </summary>
/// <param name="consoleWriter">Colored TextWriter</param>
/// <param name="text">Output Text</param>
void WriteChar(TextWriter consoleWriter, char text);
/// <summary>
/// Writes whole string and completes with newline
/// </summary>
/// <param name="consoleWriter">Colored TextWriter</param>
/// <param name="text">Output Text</param>
void WriteLine(TextWriter consoleWriter, string text);
/// <summary>
/// Default row highlight rules for the console printer
/// </summary>
IList<ConsoleRowHighlightingRule> DefaultConsoleRowHighlightingRules { get; }
}
}
#endif | 49.308943 | 163 | 0.693157 | [
"BSD-3-Clause"
] | aTiKhan/NLog | src/NLog/Targets/IColoredConsolePrinter.cs | 6,065 | C# |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("NeuralNetwork.GeneticAlgorithm")]
[assembly: AssemblyDescription("Genetic algorithm for evolving neural networks")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("NeuralNetwork.GeneticAlgorithm")]
[assembly: AssemblyCopyright("Copyright © 2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("bb0c5189-7fc1-4d26-8f4d-5e66b1d0217d")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("2.4.0.0")]
[assembly: AssemblyFileVersion("2.4.0.0")]
| 39.972973 | 84 | 0.754564 | [
"MIT"
] | jobeland/GeneticAlgorithm | NeuralNetwork.GeneticAlgorithm/Properties/AssemblyInfo.cs | 1,482 | C# |
using Dynamix;
using Fame;
using FAMIX;
using FILE;
using System;
using System.Collections.Generic;
namespace Dynamix
{
[FamePackage("Dynamix")]
[FameDescription("FieldAlias")]
public class FieldAlias : Dynamix.Alias
{
}
}
| 15.25 | 43 | 0.704918 | [
"Apache-2.0"
] | feenkcom/roslyn2famix | Roslyn2Famix/Model/Dynamix/FieldAlias.cs | 244 | C# |
Subsets and Splits