blob_id
large_stringlengths 40
40
| language
large_stringclasses 1
value | repo_name
large_stringlengths 5
119
| path
large_stringlengths 4
271
| score
float64 2.52
4.84
| int_score
int64 3
5
| text
stringlengths 26
4.09M
|
|---|---|---|---|---|---|---|
d5f4e2b182b3658f4c6e5365aa54d086137c5b2e
|
C#
|
kubilayege/Untitled-Puzzle-Game
|
/Assets/Scripts/Level/LevelInfoUI.cs
| 2.53125
| 3
|
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class LevelInfoUI : MonoBehaviour
{
public Text LevelNumberDisplay;
public GameObject contentParent;
public GameObject missionInfoPrefab;
public List<MissionInfo> missionInfos;
public static LevelInfoUI instance;
private void Awake()
{
instance = this;
}
public void DisplayLevelInfo(int levelNumber, List<Mission> missions)
{
if (missionInfos.Count != 0)
{
foreach (var missionInfo in missionInfos)
{
Destroy(missionInfo.gameObject);
}
}
missionInfos = new List<MissionInfo>();
Debug.Log("mission info count " + missionInfos.Count);
LevelNumberDisplay.text = "Level " + levelNumber;
foreach (var mission in missions)
{
missionInfos.Add(Instantiate(missionInfoPrefab, contentParent.transform).GetComponent<MissionInfo>());
missionInfos[missionInfos.Count - 1].Init(mission.animal.animalTexture, mission.Count);
}
}
}
|
2383cdbe8e9b1c54e4174c156157538b40c9e1b4
|
C#
|
ppedvAG/ASPNETCORE_WebAPI_20211004
|
/WebAPIKurs/MyFirstRestfulService/Controllers/PaggingSortingController.cs
| 2.59375
| 3
|
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MyFirstRestfulService.Data;
using MyFirstRestfulService.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace MyFirstRestfulService.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class PaggingSortingController : ControllerBase
{
private readonly MovieDbContext _dbContext;
public PaggingSortingController(MovieDbContext dbContext)
{
_dbContext = dbContext;
}
[HttpGet("EasyPageingList")]
public async Task<ActionResult<IEnumerable<Movie>>> EasyPagingList(int pageNumber, int pageSize)
{
return await _dbContext.Movies.OrderBy(o => o.Title)
.Skip((pageNumber - 1) * pageSize)
.Take(pageSize).ToListAsync();
}
[HttpGet("PagingListWithPageParametersObject")]
public async Task<ActionResult<IEnumerable<Movie>>> GetMovies([FromQuery] PageParameters parameters)
{
return await _dbContext.Movies.OrderBy(o => o.Title)
.Skip((parameters.PageNumber - 1) * parameters.PageSize)
.Take(parameters.PageSize)
.ToListAsync();
}
}
}
|
6495a12ca3266bac5740e633b3c633836f065d8b
|
C#
|
shendongnian/download4
|
/first_version_download2/274549-22072052-59123172-2.cs
| 2.53125
| 3
|
private void btnClickMe_Click(object sender, RoutedEventArgs e)
{
Popup popUp = new Popup();
// TODO: Add your elements to the popup here...
// open the popup at the same coordinates as the button
var point = CalcPopupOffsets((FrameworkElement)sender);
popUp.HorizontalOffset = point.X;
popUp.VerticalOffset = point.Y;
popUp.IsOpen = true;
}
private Point CalcPopupOffsets(FrameworkElement elem)
{
// I don't recall the exact specifics on why these
// calls are needed - but it works.
var transform = elem.TransformToVisual(this);
Point point = transform.TransformPoint(new Point(0, 0));
return point;
}
|
b6f6e607847376f2a9d39b81b6660790ef3d3cc4
|
C#
|
sanekbel/SeleniumTests
|
/Steps/NavigationSteps.cs
| 2.828125
| 3
|
using BoDi;
using OpenQA.Selenium;
using SeleniumTests.Pages;
using System;
using TechTalk.SpecFlow;
using NUnit.Framework;
namespace SeleniumTests.Steps
{
[Binding]
public class NavigationSteps
{
private IWebDriver _driver;
private BasePage _page;
public NavigationSteps(IObjectContainer objectContainer)
{
_driver = objectContainer.Resolve<IWebDriver>();
}
[Given(@"I am on the '(.*)' page")]
public void GivenIAmOnThePage(BasePage page)
{
_page = page;
_page.Open();
}
[When(@"I click '(.*)' page link on header")]
public void WhenIClickPageLink(string link)
{
_page = _page.GetHeaderElement().ClickLink(link);
}
[Then(@"'(.*)' page should be open")]
public void ThenPageShouldBeOpen(BasePage page)
{
Assert.IsTrue(page.IsPageOpen(), $"Page {page} is not opened");
}
}
}
|
745d2aed1060fb084d7ab634e7bf8ac913c64fca
|
C#
|
jplane/TheMartaBus
|
/Marta.Runtime.Entities/Trip.cs
| 2.53125
| 3
|
using Marta.Common;
using Marta.Runtime.Interfaces;
using Orleans;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Marta.Runtime.Entities
{
public class Trip : Grain, ITrip
{
private LinkedList<StopTimeInfo> _stoptimes = null;
public Task<TripInfo> GetInfo()
{
return Task.FromResult(StaticData.GetTripById((int)this.GetPrimaryKeyLong()));
}
public Task<Tuple<StopTimeInfo, StopTimeInfo>> GetStopTimes(BusSnapshotInfo status)
{
if (_stoptimes == null)
{
var times = StaticData.GetStopTimesByTripId((int)this.GetPrimaryKeyLong());
_stoptimes = new LinkedList<StopTimeInfo>(times.OrderBy(st => st.Sequence));
}
StopTimeInfo last = null;
StopTimeInfo next = null;
GetStopTimes(status, out last, out next);
return Task.FromResult(Tuple.Create(last, next));
}
private void GetStopTimes(BusSnapshotInfo status, out StopTimeInfo last, out StopTimeInfo next)
{
last = next = null;
if (_stoptimes == null)
{
return;
}
var busTime = status.AdjustedTimestamp;
LinkedListNode<StopTimeInfo> node = _stoptimes.First;
while(node != null)
{
if(busTime < node.Value.Arrival)
{
next = node.Value;
break;
}
last = node.Value;
node = node.Next;
}
}
}
}
|
cc6d46bbd4f3519a8e7321caadb0092419bb40f1
|
C#
|
isyedhassanalii/App_master
|
/App_master.Service/StructuredService.cs
| 2.96875
| 3
|
using App_master.Data.Repository;
using App_master.Model.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace App_master.Service
{
public interface IStructuredService {
IEnumerable<Structured> GetStructured();
Structured GetStructured(int id);
void CreateStructured(Structured structured);
void DeleteStructured(int id);
void UpdateStructured(Structured structured);
}
public class StructuredService : IStructuredService
{
private readonly IStructuredRepository structuredRepository;
public StructuredService(IStructuredRepository structuredRepository)
{
this.structuredRepository = structuredRepository;
}
#region IStructuredService members
public void CreateStructured(Structured structured)
{
structuredRepository.Add(structured);
}
public void DeleteStructured(int id)
{
var str = structuredRepository.GetById("id");
structuredRepository.Delete(str);
}
public IEnumerable<Structured> GetStructured()
{
var a =structuredRepository.GetAll();
return a;
}
public Structured GetStructured(int id)
{
var st = structuredRepository.GetById("id");
return st;
}
public void UpdateStructured(Structured structured)
{
structuredRepository.Update(structured);
}
#endregion
}
}
|
cf17a1020253873427fdd4a4e37b54de03ab400a
|
C#
|
luilliarcec/Global-Azure-Bootcamp-2019-Milagro
|
/Logic/Business/LogicDemo.cs
| 2.578125
| 3
|
using Data.Dao;
using Entities.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Logic.Business
{
public class LogicDemo
{
private readonly DemoDAO dao = new DemoDAO();
public bool Save(Demo demo)
{
try
{
// Si hubiera que validar hacer calculo o logica, esta es la capa para hacerlo
dao.Save(demo);
return true;
}
catch (Exception)
{
throw;
}
}
public IReadOnlyList<Demo> GetDemos()
{
try
{
return dao.GetDemos();
}
catch (Exception)
{
throw;
}
}
// El resto de metodos lo implementaran uds.
}
}
|
43c5178cf0978ef54886a583fdeeaac6d06e00c2
|
C#
|
roytown/Bag
|
/Web/ResourceElement.cs
| 2.625
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;
using System.Globalization;
namespace Web
{
public class ResourceElement : ConfigurationElement
{
private static readonly ConfigurationProperty _Name;
private static readonly ConfigurationProperty _Value;
private static readonly ConfigurationProperty _Purviews;
private static ConfigurationPropertyCollection _Properties;
static ResourceElement()
{
_Name = new ConfigurationProperty("name", typeof(string), string.Empty, ConfigurationPropertyOptions.IsKey | ConfigurationPropertyOptions.IsRequired);
_Value = new ConfigurationProperty("value", typeof(string), string.Empty, ConfigurationPropertyOptions.IsRequired);
_Purviews = new ConfigurationProperty(null, typeof(ResourcePurviewElementCollection), null, ConfigurationPropertyOptions.IsDefaultCollection);
_Properties = new ConfigurationPropertyCollection();
}
public ResourceElement()
{
_Properties.Add(_Name);
_Properties.Add(_Value);
_Properties.Add(_Purviews);
}
public ResourceElement(string name)
{
this.Name = name;
}
[ConfigurationProperty("name", IsKey = true, IsRequired = true)]
public string Name
{
get
{
return ((string)base[_Name]).ToLower(CultureInfo.CurrentCulture);
}
set
{
base[_Name] = value;
}
}
[ConfigurationProperty("value", IsRequired = true)]
public string Value
{
get
{
return (string)base[_Value];
}
set
{
base[_Value] = value;
}
}
[ConfigurationProperty("purview", IsDefaultCollection = true)]
public ResourcePurviewElementCollection Purviews
{
get
{
return (ResourcePurviewElementCollection)base[_Purviews];
}
}
protected override ConfigurationPropertyCollection Properties
{
get
{
return _Properties;
}
}
}
}
|
568fdf9343a436300eac18661ea4a5811db0c462
|
C#
|
krisam2408/ColorRose
|
/ColorRoseWPF/Core/LayoutBehaviour.cs
| 2.640625
| 3
|
using System.Windows;
using System.Windows.Input;
namespace ColorRoseWPF.Core
{
public class LayoutBehaviour
{
public static readonly DependencyProperty ResizeCommandProperty = DependencyProperty.RegisterAttached("ResizeCommand", typeof(ICommand), typeof(LayoutBehaviour), new FrameworkPropertyMetadata(new PropertyChangedCallback(ResizeCommandChanged)));
public static readonly DependencyProperty LoadedCommandProperty = DependencyProperty.RegisterAttached("LoadedCommand", typeof(ICommand), typeof(LayoutBehaviour), new FrameworkPropertyMetadata(new PropertyChangedCallback(LoadedCommandChanged)));
private static void ResizeCommandChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
FrameworkElement element = (FrameworkElement)sender;
element.SizeChanged += new SizeChangedEventHandler(ResizeCommand);
}
private static void ResizeCommand(object sender, SizeChangedEventArgs e)
{
FrameworkElement element = (FrameworkElement)sender;
ICommand command = GetResizeCommand(element);
command.Execute(e);
}
public static void SetResizeCommand(FrameworkElement element, ICommand command)
{
element.SetValue(ResizeCommandProperty, command);
}
public static ICommand GetResizeCommand(FrameworkElement element)
{
return (ICommand)element.GetValue(ResizeCommandProperty);
}
private static void LoadedCommandChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
FrameworkElement element = (FrameworkElement)sender;
element.Loaded += new RoutedEventHandler(LoadedCommand);
}
private static void LoadedCommand(object sender, RoutedEventArgs e)
{
FrameworkElement element = (FrameworkElement)sender;
ICommand command = GetLoadedCommand(element);
command.Execute(e);
}
public static void SetLoadedCommand(FrameworkElement element, ICommand command)
{
element.SetValue(LoadedCommandProperty, command);
}
public static ICommand GetLoadedCommand(FrameworkElement element)
{
return (ICommand)element.GetValue(LoadedCommandProperty);
}
}
}
|
cc553951fa6d4da01b44bcf9efc5b2eec1691196
|
C#
|
MigleVai/CinemaSimulation
|
/AntraTOPMigle/Class/WorkerList.cs
| 2.953125
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AntraTOPMigle.Class
{
class WorkerList<T>
{
List<T> listWorker = new List<T>();
public void AddObject(T thing)
{
listWorker.Add(thing);
}
public void RemoveObject(int index)
{
listWorker.RemoveAt(index);
}
public List<T> ReturnList()
{
return listWorker;
}
public void SetList(List<T> another)
{
listWorker = another;
}
}
}
|
d3516eca633fe588f95198b2d32010b1ae657d26
|
C#
|
stkromm/battlesystem
|
/GameObjectExtension.cs
| 2.75
| 3
|
using UnityEngine;
public static class GameObjectExtension
{
public static T GetSafeComponent<T>(this GameObject obj) where T : MyMonoBehaviour
{
var component = obj.GetComponent<T>();
if (component == null)
{
Debug.LogError("Expected to find component of type "
+ typeof(T) + " but found none", obj);
}
return component;
}
}
|
225b606f8047c77732a5c463f70e9b85a5aab3ac
|
C#
|
PabloMuralles/Analizador
|
/Analizador/MetodosEstaticos.cs
| 3.28125
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Analizador
{
class MetodosEstaticos
{
/// <summary>
/// Metodo para realizar la tokenizacion de la cadena entrada
/// </summary>
/// <param name="CadenaEntrada">Cadena de entrada a evaluar</param>
/// <param name="TokensNoExpresiones">La lista de tokens sin que sean expresiones regulares </param>
/// <returns>Una cola con la cadena tokenizada</returns>
public Queue<string> Tokenizar(string CadenaEntrada, List<string> TokensNoExpresiones)
{
try
{
Queue<string> tokens = new Queue<string>();
string[] elements = CadenaEntrada.Split(new[] { "\r\n", "\r", "\n", "\t", " " }, StringSplitOptions.None);
foreach (string element in elements)
{
if (!string.IsNullOrWhiteSpace(element) && !string.IsNullOrEmpty(element))
{
List<string> find = TokensNoExpresiones.FindAll(x => element.Contains(x));
if (find.Count() == 0)
{
tokens.Enqueue(element);
}
else
{
var greatestElement = find.OrderByDescending(x => x.Length).FirstOrDefault();
int index = element.IndexOf(greatestElement);
string newElement = string.Empty;
if (index == 0)
{
tokens.Enqueue(element.Substring(0, greatestElement.Length));
newElement = element.Remove(0, greatestElement.Length);
}
else
{
tokens.Enqueue(element.Substring(0, index));
newElement = element.Remove(0, index);
}
while (newElement.Length > 0)
{
find = TokensNoExpresiones.FindAll(x => newElement.Contains(x));
if (find.Count() == 0)
{
tokens.Enqueue(newElement);
newElement = string.Empty;
}
else
{
index = newElement.IndexOf(newElement);
if (index == 0)
{
tokens.Enqueue(newElement.Substring(0, newElement.Length));
newElement = newElement.Remove(0, newElement.Length);
}
else
{
tokens.Enqueue(newElement.Substring(0, index));
newElement = newElement.Remove(0, index);
}
}
}
}
}
}
return tokens;
}
catch (Exception)
{
}
return default;
}
/// <summary>
/// Metodo para poder saber a que token le pertenece cada parte de la cadena o tambien las reservadas
/// </summary>
/// <param name="TokensCadena">una cola de los tokens de la cadena recibida por el usuario</param>
/// <param name="TokensGramatica">son todos los tokens de la gramatica con las reservads</param>
/// <param name="Sets">los sets con sus rangos para poder verificar con cada token que es una expresion regular</param>
/// <returns>una lista con los tokens de la cadena de entrada con cada uno de sus respectivos token o reservas</returns>
public List<string> MostrarTokens(Queue<string> TokensCadena, Dictionary<string, string> TokensGramatica, Dictionary<string, List<string>> Sets)
{
try
{
var ListaMostrarTokens = new List<string>();
while (TokensCadena.Count != 0)
{
var Token = TokensCadena.Dequeue();
if (TokensGramatica.Values.Contains(Token))
{
var TokenPertenece = string.Empty;
TokenPertenece += TokensGramatica.FirstOrDefault(x => x.Value == Token).Key.ToString();
TokenPertenece += $"= {Token }";
ListaMostrarTokens.Add(TokenPertenece);
}
else
{
if (Token.Length == 1)
{
var TokenPertenece = string.Empty;
foreach (var item in Sets)
{
var end = false;
if (item.Value.Contains(Token))
{
foreach (var token in TokensGramatica)
{
if (token.Value.Contains(item.Key))
{
TokenPertenece += token.Key.ToString();
TokenPertenece += $"= {Token}";
ListaMostrarTokens.Add(TokenPertenece);
end = true;
break;
}
}
if (end == true)
{
break;
}
}
}
}
else
{
var Aux = string.Empty;
var Concatenacion = string.Empty;
var contador = 1;
foreach (var caracter in Token)
{
var end = false;
var TokenPertenece = string.Empty;
foreach (var item in Sets)
{
if (item.Value.Contains(caracter.ToString()))
{
foreach (var token in TokensGramatica)
{
if (token.Value.Contains(item.Key))
{
if (Aux.Length == 0)
{
Aux = token.Key;
Concatenacion += caracter;
if (contador == Token.Length)
{
TokenPertenece = $"{Aux} = {Concatenacion}";
ListaMostrarTokens.Add(TokenPertenece);
Concatenacion = string.Empty;
TokenPertenece = string.Empty;
}
end = true;
break;
}
else if (Aux == token.Key)
{
Concatenacion += caracter;
if (Token.Length == Concatenacion.Length)
{
TokenPertenece = $"{Aux} = {Concatenacion}";
ListaMostrarTokens.Add(TokenPertenece);
Concatenacion = string.Empty;
TokenPertenece = string.Empty;
}
end = true;
break;
}
else if (Aux != token.Key)
{
TokenPertenece = $"{Aux} = {Concatenacion}";
ListaMostrarTokens.Add(TokenPertenece);
Aux = token.Key;
Concatenacion = string.Empty;
TokenPertenece = string.Empty;
}
end = true;
break;
}
}
if (end == true)
{
break;
}
}
else
{
if (TokensGramatica.Values.Contains(caracter.ToString()))
{
TokenPertenece = string.Empty;
TokenPertenece = $"{TokensGramatica.FirstOrDefault(x => x.Value == caracter.ToString()).Key.ToString()} = {caracter}";
ListaMostrarTokens.Add(TokenPertenece);
TokenPertenece = string.Empty;
break;
}
}
}
contador++;
}
if (Concatenacion.Length != 0)
{
var TokenPertenece = $"{Aux} = {Concatenacion}";
ListaMostrarTokens.Add(TokenPertenece);
Concatenacion = string.Empty;
TokenPertenece = string.Empty;
}
}
}
}
return ListaMostrarTokens;
}
catch (Exception)
{
}
return default;
}
}
}
|
10bd566ceba0a1e05ca3c0b0a08f64c74fb3351d
|
C#
|
shlomoamor/OOP_Programming
|
/B19 Ex02 ShlomoAmor 000803254/B19_Ex02/Program.cs
| 2.921875
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace B19_Ex02
{
/** This class is responsible for creating a new game and calling the runGame method*/
public class Program
{
public static void Main(String[] args)
{
BullsAndCowsGame game = new BullsAndCowsGame();
game.RunGame();
Console.Write("Please enter to exit..");
Console.Read();
}
}
}
|
e69eb1427afdf972288a79476258d051ae7820a2
|
C#
|
archygupta/DS-Algo
|
/src/CodeWithMosh/DataStructures - Part-1/QueueUsingStack.cs
| 3.84375
| 4
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataStructures
{
class QueueUsingStack
{
private Stack<int> stack1;
private Stack<int> stack2;
private readonly int size;
public QueueUsingStack(int size)
{
stack1 = new Stack<int>(size);
stack2 = new Stack<int>(size);
this.size = size;
}
public void Enqueue(int number)
{
if (stack1.Count == size)
{
throw new StackOverflowException("Stack1 is full!");
}
if (stack2.Count == size)
{
throw new StackOverflowException("Stack2 is full!");
}
stack1.Push(number);
}
public int Dequeue()
{
if (stack2.Count == 0)
{
while (stack1.Count != 0)
{
stack2.Push(stack1.Pop());
}
}
return stack2.Pop();
}
}
}
|
ac7f28673d71118d4ac5a049b19cd80e2b92b25f
|
C#
|
shendongnian/download4
|
/code1/51188-6480414-14112453-4.cs
| 3.09375
| 3
|
enum HowNice
{
ReallyNice,
SortOfNice,
NotNice
}
/// <summary>
/// This method is for filling a listcontrol,
/// such as dropdownlist, listbox...
/// with an enum as the datasource.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="ctrl"></param>
/// <param name="resourceClassName"></param>
public static void OwFillDataWithEnum<T>(ListControl ctrl, string resourceClassName)
{
var owType = typeof(T);
var values = Enum.GetValues(owType);
for (var i = 0; i < values.Length; i++)
{
//Localize this for displaying listcontrol's text field.
var text = OwToStringByCulture(resourceClassName, Enum.Parse(owType, values.GetValue(i).ToString()).ToString());
//This is for listcontrol's value field
var key = (Enum.Parse(owType, values.GetValue(i).ToString()));
//add values of enum to listcontrol.
ctrl.Items.Add(new ListItem(text, key.ToString()));
}
}
/// <summary>
/// Get localized strings.
/// </summary>
/// <param name="resourceClassName"></param>
/// <param name="resourceKey"></param>
/// <returns></returns>
public static string OwToStringByCulture(string resourceClassName, string resourceKey)
{
return (string)HttpContext.GetGlobalResourceObject(resourceClassName, resourceKey);
}
}
|
b384138cd7c74db658a1ca60f73ed3ea4b730d56
|
C#
|
Kawser-nerd/CLCDSA
|
/Source Codes/AtCoder/abc030/C/4411226.cs
| 3.265625
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using static Input;
public class Prog
{
private const int INF = 1000000007;
public static void Main()
{
int N = NextInt();
int M = NextInt();
int X = NextInt();
int Y = NextInt();
int[] a = LineInt();
List<int> ai = a.ToList();
a = LineInt();
List<int> bi = a.ToList();
int now = 0;
int ans = 0;
bool air_a = true;
while (true)
{
if (air_a)
{
//A?????
int x = MoreSearch(ai, now);
if (x == N) break;
now = ai[x] + X;
air_a = false;
}
else
{
int x = MoreSearch(bi, now);
if (x == M) break;
now = bi[x] + Y;
ans += 1;
air_a = true;
}
}
Console.WriteLine(ans);
}
private static int MoreSearch(List<int> list, long n)
{
int a = 0, b = list.Count();
if (list[a] >= n) return a;
else if (list[b - 1] < n) return b;
while (b - a != 1)
{
int x = (a + b) / 2;
if (list[x] >= n) b = x;
else a = x;
}
return b;
}
}
public class Input
{
private static Queue<string> q = new Queue<string>();
private static void Confirm() { if (q.Count == 0) foreach (var s in Console.ReadLine().Split(' ')) q.Enqueue(s); }
public static int NextInt() { Confirm(); return int.Parse(q.Dequeue()); }
public static long NextLong() { Confirm(); return long.Parse(q.Dequeue()); }
public static string NextString() { Confirm(); return q.Dequeue(); }
public static double NextDouble() { Confirm(); return double.Parse(q.Dequeue()); }
public static int[] LineInt() { return Console.ReadLine().Split(' ').Select(int.Parse).ToArray(); }
public static long[] LineLong() { return Console.ReadLine().Split(' ').Select(long.Parse).ToArray(); }
public static string[] LineString() { return Console.ReadLine().Split(' ').ToArray(); }
public static double[] LineDouble() { return Console.ReadLine().Split(' ').Select(double.Parse).ToArray(); }
}
|
8a05297eb0caa2713c95ef53f00ab1da30301771
|
C#
|
ripo4ek/SomeCode
|
/lesson 3/ActionsAndTriggers(5)/ActionsAndTriggers/TimerTrigger.cs
| 2.765625
| 3
|
using System.Timers;
using System.Windows.Forms;
namespace ActionsAndTriggers
{
//в секундах (int) сделал для разнообразия, понимаю что лучше datetime
class TimerTrigger : TriggerableEntity
{
private PowerStatus _powerStatus;
public int TriggerTime { get;}
private int _timer;
public TimerTrigger(int triggerTime)
{
TriggerTime = triggerTime;
_powerStatus = SystemInformation.PowerStatus;
}
protected override void CheckСondition(object source, ElapsedEventArgs e)
{
IncrementTimer();
if (_timer > TriggerTime)
{
IsTriggered = true;
base.Stop();
}
}
private void IncrementTimer()
{
_timer++;
}
}
}
|
a32feddc397553102b1863d92b383e6fb8edebc5
|
C#
|
FairPlayer4/CSharpUtils
|
/CSharpUtilsNETStandard/Utils/Collections/DictionaryList.cs
| 2.96875
| 3
|
#region Imports
using System;
using System.Collections;
using System.Collections.Generic;
using JetBrains.Annotations;
#endregion
namespace CSharpUtilsNETStandard.Utils.Collections
{
/// <summary>
/// Keeps the order of keys that are inserted into the DictionaryList.
/// Initially the keys are ordered according to the insertion order.
/// However this can be changed by functionality provided by the IListUtil.
/// The standard enumerator will enumerate the KeyValuePairs according to the order of the underlying list.
/// The property IsInsertionOrder will indicate if the order is still the insertion order.
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
[PublicAPI]
public sealed class DictionaryList<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionaryList<TKey, TValue>, IListUtil<TKey>
{
[NotNull]
private readonly Dictionary<TKey, TValue> dictionary;
[NotNull, ItemNotNull]
private readonly SetList<TKey> keySetList;
public DictionaryList()
{
dictionary = new Dictionary<TKey, TValue>();
keySetList = new SetList<TKey>();
}
public DictionaryList([CanBeNull] IEqualityComparer<TKey> comparer)
{
dictionary = new Dictionary<TKey, TValue>(comparer);
keySetList = new SetList<TKey>(comparer);
}
public DictionaryList(int capacity)
{
dictionary = new Dictionary<TKey, TValue>(capacity);
keySetList = new SetList<TKey>(capacity);
}
public DictionaryList(int capacity, [CanBeNull] IEqualityComparer<TKey> comparer)
{
dictionary = new Dictionary<TKey, TValue>(capacity, comparer);
keySetList = new SetList<TKey>(capacity, comparer);
}
public DictionaryList([NotNull] IDictionary<TKey, TValue> dictionary)
{
this.dictionary = new Dictionary<TKey, TValue>(dictionary);
keySetList = new SetList<TKey>(dictionary.Keys);
}
public DictionaryList([NotNull] IDictionary<TKey, TValue> dictionary, [CanBeNull] IEqualityComparer<TKey> comparer)
{
this.dictionary = new Dictionary<TKey, TValue>(dictionary, comparer);
keySetList = new SetList<TKey>(dictionary.Keys, comparer);
}
public bool IsInsertionOrder { get; private set; } = true;
/// <summary>
/// Returns the list of keys by the order of their insertion to the DictionaryList.
/// </summary>
public IReadOnlyList<TKey> KeyList => keySetList.AsReadOnly;
public int Count => keySetList.Count;
public ICollection<TKey> Keys => dictionary.Keys;
public ICollection<TValue> Values => dictionary.Values;
[CanBeNull]
public TValue this[TKey key]
{
get => dictionary[key];
set
{
dictionary[key] = value;
keySetList.Add(key);
}
}
[NotNull]
TKey IReadOnlyList<TKey>.this[int index] => GetKeyAt(index);
KeyValuePair<TKey, TValue> IReadOnlyList<KeyValuePair<TKey, TValue>>.this[int index] => GetAt(index);
[NotNull]
public TKey GetKeyAt(int index) => keySetList[index];
[CanBeNull]
public TValue GetValueAt(int index) => this[GetKeyAt(index)];
public KeyValuePair<TKey, TValue> GetAt(int index)
{
TKey key = GetKeyAt(index);
return new KeyValuePair<TKey, TValue>(key, this[key]);
}
public TValue GetValueOrDefault(TKey key, TValue defaultValue = default)
{
return TryGetValue(key, out TValue result) ? result : defaultValue;
}
public void Add(TKey key, [CanBeNull] TValue value)
{
dictionary.Add(key, value);
keySetList.Add(key);
}
public bool Remove(TKey key)
{
bool removeResult = dictionary.Remove(key) && keySetList.Remove(key);
if (Count <= 1) IsInsertionOrder = true;
return removeResult;
}
public void Clear()
{
dictionary.Clear();
keySetList.Clear();
IsInsertionOrder = true;
}
public bool ContainsKey(TKey key) => keySetList.Contains(key);
public bool ContainsValue(TValue value) => dictionary.ContainsValue(value);
public bool TryGetValue(TKey key, out TValue value) => dictionary.TryGetValue(key, out value);
public DictionaryListEnumerator GetEnumerator() => new DictionaryListEnumerator(dictionary, keySetList);
#region Implicit Implementations
IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => ((IReadOnlyDictionary<TKey, TValue>)dictionary).Keys;
IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => ((IReadOnlyDictionary<TKey, TValue>)dictionary).Values;
void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
{
((ICollection<KeyValuePair<TKey, TValue>>)dictionary).Add(item);
keySetList.Add(item.Key);
}
bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) => ((ICollection<KeyValuePair<TKey, TValue>>)dictionary).Contains(item);
bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
{
bool removeResult = ((ICollection<KeyValuePair<TKey, TValue>>)dictionary).Remove(item) && keySetList.Remove(item.Key);
if (Count <= 1) IsInsertionOrder = true;
return removeResult;
}
bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => ((ICollection<KeyValuePair<TKey, TValue>>)dictionary).IsReadOnly;
void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
{
((ICollection<KeyValuePair<TKey, TValue>>)dictionary).CopyTo(array, arrayIndex);
}
void ICollection.CopyTo(Array array, int index)
{
((ICollection)dictionary).CopyTo(array, index);
}
bool ICollection.IsSynchronized => ((ICollection)dictionary).IsSynchronized;
object ICollection.SyncRoot => ((ICollection)dictionary).SyncRoot;
bool IDictionary.IsFixedSize => ((IDictionary)dictionary).IsFixedSize;
bool IDictionary.IsReadOnly => ((IDictionary)dictionary).IsReadOnly;
ICollection IDictionary.Keys => ((IDictionary)dictionary).Keys;
ICollection IDictionary.Values => ((IDictionary)dictionary).Values;
[CanBeNull]
object IDictionary.this[object key]
{
get => ((IDictionary)dictionary)[key];
set
{
((IDictionary)dictionary)[key] = value;
((IList)keySetList).Add(key);
}
}
void IDictionary.Add(object key, [CanBeNull] object value)
{
((IDictionary)dictionary).Add(key, value);
((IList)keySetList).Add(key);
}
bool IDictionary.Contains(object key) => ((IDictionary)dictionary).Contains(key);
void IDictionary.Remove(object key)
{
((IDictionary)dictionary).Remove(key);
((IList)keySetList).Remove(key);
}
IDictionaryEnumerator IDictionary.GetEnumerator() => GetEnumerator();
IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator() => keySetList.GetEnumerator();
IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator() => GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
#endregion
#region Special Enumerator
public struct DictionaryListEnumerator : IEnumerator<KeyValuePair<TKey, TValue>>,
IDictionaryEnumerator
{
[NotNull]
private readonly Dictionary<TKey, TValue> dictionary;
private Dictionary<TKey, TValue>.Enumerator dictionaryEnumerator;
[NotNull]
private readonly IEnumerator<TKey> listEnumerator;
internal DictionaryListEnumerator([NotNull] Dictionary<TKey, TValue> dictionary, [NotNull] SetList<TKey> list) : this()
{
this.dictionary = dictionary;
dictionaryEnumerator = dictionary.GetEnumerator();
listEnumerator = list.GetEnumerator();
Current = new KeyValuePair<TKey, TValue>();
}
public void Dispose() { }
public bool MoveNext()
{
if (!dictionaryEnumerator.MoveNext() || !listEnumerator.MoveNext() || listEnumerator.Current == null) return false;
Current = new KeyValuePair<TKey, TValue>(listEnumerator.Current, dictionary[listEnumerator.Current]);
return true;
}
void IEnumerator.Reset()
{
((IEnumerator)dictionaryEnumerator).Reset();
listEnumerator.Reset();
Current = new KeyValuePair<TKey, TValue>();
}
DictionaryEntry IDictionaryEnumerator.Entry
{
get
{
DictionaryEntry entry = ((IDictionaryEnumerator)dictionaryEnumerator).Entry;
return new DictionaryEntry(Current.Key, Current.Value);
}
}
object IDictionaryEnumerator.Key
{
get
{
object key = ((IDictionaryEnumerator)dictionaryEnumerator).Key;
return Current.Key;
}
}
[CanBeNull]
object IDictionaryEnumerator.Value
{
get
{
object value = ((IDictionaryEnumerator)dictionaryEnumerator).Value;
return Current.Value;
}
}
public KeyValuePair<TKey, TValue> Current { get; private set; }
[NotNull]
object IEnumerator.Current
{
get
{
if (((IEnumerator)dictionaryEnumerator).Current is DictionaryEntry) return new DictionaryEntry(Current.Key, Current.Value);
return new KeyValuePair<TKey, TValue>(Current.Key, Current.Value);
}
}
}
#endregion
#region IListUtil Implementation
public int BinarySearch(int index, int count, TKey item, IComparer<TKey> comparer) => keySetList.BinarySearch(index, count, item, comparer);
public int BinarySearch(TKey item) => keySetList.BinarySearch(item);
public int BinarySearch(TKey item, IComparer<TKey> comparer) => keySetList.BinarySearch(item, comparer);
public List<TOutput> ConvertAll<TOutput>(Converter<TKey, TOutput> converter) => keySetList.ConvertAll(converter);
public void CopyTo(TKey[] array)
{
keySetList.CopyTo(array);
}
public void CopyTo(TKey[] array, int arrayIndex)
{
keySetList.CopyTo(array, arrayIndex);
}
public void CopyTo(int index, TKey[] array, int arrayIndex, int count)
{
keySetList.CopyTo(index, array, arrayIndex, count);
}
public bool Exists(Predicate<TKey> match) => keySetList.Exists(match);
public TKey Find(Predicate<TKey> match) => keySetList.Find(match);
public List<TKey> FindAll(Predicate<TKey> match) => keySetList.FindAll(match);
public int FindIndex(Predicate<TKey> match) => keySetList.FindIndex(match);
public int FindIndex(int startIndex, Predicate<TKey> match) => keySetList.FindIndex(startIndex, match);
public int FindIndex(int startIndex, int count, Predicate<TKey> match) => keySetList.FindIndex(startIndex, count, match);
public TKey FindLast(Predicate<TKey> match) => keySetList.FindLast(match);
public int FindLastIndex(Predicate<TKey> match) => keySetList.FindLastIndex(match);
public int FindLastIndex(int startIndex, Predicate<TKey> match) => keySetList.FindLastIndex(startIndex, match);
public int FindLastIndex(int startIndex, int count, Predicate<TKey> match) => keySetList.FindLastIndex(startIndex, count, match);
public void ForEach(Action<TKey> action)
{
keySetList.ForEach(action);
}
public List<TKey> GetRange(int index, int count) => keySetList.GetRange(index, count);
public int IndexOf(TKey item) => keySetList.IndexOf(item);
public int IndexOf(TKey item, int index) => keySetList.IndexOf(item, index);
public int IndexOf(TKey item, int index, int count) => keySetList.IndexOf(item, index, count);
public int LastIndexOf(TKey item) => keySetList.LastIndexOf(item);
public int LastIndexOf(TKey item, int index) => keySetList.LastIndexOf(item, index);
public int LastIndexOf(TKey item, int index, int count) => keySetList.LastIndexOf(item, index, count);
public void Reverse()
{
keySetList.Reverse();
IsInsertionOrder = false;
}
public void Reverse(int index, int count)
{
keySetList.Reverse(index, count);
IsInsertionOrder = false;
}
public void Sort()
{
keySetList.Sort();
IsInsertionOrder = false;
}
public void Sort(IComparer<TKey> comparer)
{
keySetList.Sort(comparer);
IsInsertionOrder = false;
}
public void Sort(int index, int count, IComparer<TKey> comparer)
{
keySetList.Sort(index, count, comparer);
IsInsertionOrder = false;
}
public void Sort(Comparison<TKey> comparison)
{
keySetList.Sort(comparison);
IsInsertionOrder = false;
}
public TKey[] ToArray() => keySetList.ToArray();
public void TrimExcess()
{
keySetList.TrimExcess();
}
public bool TrueForAll(Predicate<TKey> match) => keySetList.TrueForAll(match);
#endregion
}
}
|
e5e0951541d067e54e91e7206a57f4a9cfe15e48
|
C#
|
shendongnian/download4
|
/code5/943413-23775795-65578367-2.cs
| 3.328125
| 3
|
public static class ClassPropTextSearch
{
private static Dictionary<Type, List<PropertyInfo>> _stringProperties =
new Dictionary<Type, List<PropertyInfo>>();
public static bool Match(object item, string searchTerm)
{
// Skip null checking ...
if (!_stringProperties.ContainsKey(item.GetType()))
{
// Retrieve and store the list of string properties of the input's type
var stringProperties = item.GetType()
.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.SetProperty)
.Where(p => p.PropertyType == typeof(string))
.ToList();
_stringProperties.Add(item.GetType(), stringProperties);
}
return _stringProperties[item.GetType()]
.Select(prop => prop.GetValue(item, null))
.OfType<string>()
.Any(value => value != null && value.ToLower().Contains(searchTerm.ToLower()));
}
}
|
c9cbe5c8146db1cf2cd6e5f971b5317a01a73e6f
|
C#
|
fearnoevil7/CSharp
|
/ORM/EntityFramework/Login/Controllers/HomeController.cs
| 2.5625
| 3
|
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;
using Login.Models;
using System.Linq;
using Microsoft.AspNetCore.Identity;
namespace Login.Controllers
{
public class HomeController : Controller
{
private MyContext dbContext;
public HomeController(MyContext context)
{
dbContext = context;
}
[HttpGet]
[Route("")]
public ViewResult Index()
{
return View();
}
[HttpPost]
[Route("/register")]
public IActionResult Create(User user)
{
if (ModelState.IsValid)
{
if(dbContext.Users.Any(user1 => user1.email == user.email))
{
ModelState.AddModelError("Email", "Email already in use!");
}
PasswordHasher <User> Hasher = new PasswordHasher<User>();
User newUser = new User()
{
firstName = user.firstName,
lastName = user.lastName,
email = user.email,
password = Hasher.HashPassword(user, user.password),
};
dbContext.Users.Add(newUser);
dbContext.SaveChanges();
return RedirectToAction("Index");
}
else
{
Console.WriteLine("Registration failed!");
return View("Index");
}
}
[HttpPost]
[Route("/session/create")]
public IActionResult Login(LoginUser usersubmission)
{
if (ModelState.IsValid)
{
var userInDB = dbContext.Users.FirstOrDefault(user => user.email == usersubmission.email);
if (userInDB == null)
{
ModelState.AddModelError("Email", "Invalid Email");
return View("Index");
}
var hasher = new PasswordHasher<LoginUser>();
var result = hasher.VerifyHashedPassword(usersubmission, userInDB.password, usersubmission.password);
if (result == 0)
{
ModelState.AddModelError("Password", "Invalid Password");
return View("Index");
}
// User user1 = dbContext.Users.FirstOrDefault(user => user.email == usersubmission.email);
Console.WriteLine(result);
Console.WriteLine("*******!!!!!!!!!!!!!*******", result);
HttpContext.Session.SetInt32("UserId", userInDB.id);
int? id = HttpContext.Session.GetInt32("UserId");
Console.WriteLine(id);
return View("Success");
}
else
{
Console.WriteLine("*******ModelState IsValid failed*******");
return View("Index");
}
}
[HttpGet]
[Route("/login")]
public ViewResult Login()
{
return View();
}
[HttpGet]
[Route("/success")]
public IActionResult Success()
{
int? currentIdInSession = HttpContext.Session.GetInt32("UserId");
if (currentIdInSession != null)
{
return View("Success");
}
else
{
ModelState.AddModelError("id", "User not in session");
return RedirectToAction("Index");
}
}
[HttpGet]
[Route("/logout")]
public RedirectToActionResult Logout()
{
HttpContext.Session.Clear();
return RedirectToAction("Index");
}
}
}
|
aea40e97d61d31ccb0c91e087196638e29de8595
|
C#
|
viniolimpio3/CSharp-Database-Connection
|
/Database_Connection/Util.cs
| 2.78125
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Database_Connection
{
class Util
{
private object response;
public void sair()
{
this.response = MessageBox.Show("Deseja sair dessa aplicação?", "" +
"***FINALIZANDO***",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2);
if (response.Equals(DialogResult.Yes)) Application.Exit();
}
public void limparControles(Control c)
{
foreach (Control caixa in c.Controls){
if(caixa is TextBox){
(( TextBox )caixa).Clear();
}else{
limparControles(caixa);
}
}
}
}
}
|
cc06a73091d64c573f2350dd8f421b6e958c7db4
|
C#
|
ItsJustMeChris/IST-210
|
/Lab 12 Array/Lab 12 Array/Program.cs
| 3.640625
| 4
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Lab_12_Array
{
class Program
{
static void Main(string[] args)
{
int[] arr = new int[10];
arr[0] = 77; // insert 10 items
arr[1] = 99;
arr[2] = 44;
arr[3] = 55;
arr[4] = 22;
arr[5] = 88;
arr[6] = 11;
arr[7] = 3;
arr[8] = 66;
arr[9] = 33;
int nElems = 10;
ArrayObject ao = new ArrayObject(arr, nElems);
ao.displayAll();
ao.displayAt(6);
ao.find(55);
ao.delete(55);
ao.find(55);
ao.displayAll();
ao.bubbleSort();
Console.WriteLine("Sorting the array");
ao.displayAll();
ao.insert(49);
Console.ReadLine();
}
}
}
/*
* Displaying all members of the array
77 99 44 55 22 88 11 3 66 33
Display element at index 6 of the array
Value at index 6 is: 11
Find 55 in the array
Number 55 was found at index 3 of the array
Delete 55 from the array
Find 55 in the array
Number 55 was NOT found
Displaying all members of the array
77 99 44 22 88 11 3 66 33 0 0
Sorting the array
Displaying all members of the array
3 11 22 33 44 66 77 88 99 0 0
Insert 49 into the array and then display the array
Displaying all members of the array
3 11 22 33 44 66 77 88 99 49
*/
|
3bf10d19954ff12c4d18579af18d61d27d306b8d
|
C#
|
vishaljain1981/CoachingManagementSystem
|
/DataContainerClasses/Class.cs
| 3.046875
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.OleDb;
namespace CoachingManagementSystem
{
class Class : CoachingBase
{
#region fields
// All fidels of table, name of these fields should be exactly
// same as table's field in the database
private int class_id;
public int Class_id
{
get { return class_id; }
set { class_id = value; }
}
private string className;
public string ClassName
{
get { return className; }
set { className = value; }
}
private string classDescription;
public string ClassDescription
{
get { return classDescription; }
set { classDescription = value; }
}
#endregion fields
#region Save Methods
/// <summary>
/// Object Specific - Mehod to build string for insert data into db
/// </summary>
/// <returns></returns>
override public string buildStringForInsert()
{
string FieldNames = "";
string FieldValues = "";
if (!string.IsNullOrEmpty(classDescription))
{
FieldNames += getInsertStringField(DatabaseCoachingInst.Class.ClassDescription.ToString());// Coming from Table in Database
FieldValues += getInsertStringFieldValue(classDescription);// Coming from C# FORM
}
if (!string.IsNullOrEmpty(className))
{
FieldNames += getInsertStringField(DatabaseCoachingInst.Class.ClassName.ToString());// Coming from Table in Database
FieldValues += getInsertStringFieldValue(className);// Coming from C# FORM
}
string insertIntoString = getFinalInsertString(DatabaseCoachingInst.Tables.Class.ToString(), FieldNames, FieldValues);
return insertIntoString;
}
#endregion Save Method
#region Query
/// <summary>
/// Object Specific function
/// </summary>
/// <param name="dr"></param>
/// <returns></returns>
override public object convertFromReader(OleDbDataReader dr)
{
Class gotFromDB = new Class();
gotFromDB.class_id = int.Parse(dr[DatabaseCoachingInst.Class.Class_id.ToString()].ToString());
gotFromDB.classDescription = dr[DatabaseCoachingInst.Class.ClassDescription.ToString()].ToString();
gotFromDB.className = dr[DatabaseCoachingInst.Class.ClassName.ToString()].ToString();
// write similar code for other fields.
return gotFromDB;
}
/// <summary>
/// Object spcivic method
/// </summary>
/// <returns></returns>
override public string buildStringForQuery()
{
// Select * from User where userName='Vishal' and address='XYZ'
string queryStr = "";
if (!string.IsNullOrEmpty(className))
{
queryStr += getQueryPartialString(DatabaseCoachingInst.Class.ClassName.ToString(), className); //" User_Name = '" + user_name + "' and";
}
if (!string.IsNullOrEmpty(classDescription))
{
queryStr += getQueryPartialString(DatabaseCoachingInst.Class.ClassDescription.ToString(), classDescription); //" User_Name = '" + user_name + "' and";
}
if (class_id != null && class_id != 0)
{
queryStr += getQueryPartialString(DatabaseCoachingInst.Class.Class_id.ToString(), class_id); //" User_Name = '" + user_name + "' and";
}
queryStr = getFinalQueryString(queryStr, DatabaseCoachingInst.Tables.Class.ToString());
return queryStr;
}
#endregion Query
}
}
|
531574c7a3645f82831fdc2dade136c26ce4d566
|
C#
|
JelleStu/FontysSoftware
|
/Deelproducten_software/toolbox basis/MBO_Opdracht/opdracht_1/Form1.cs
| 2.890625
| 3
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace opdracht_1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
}
private void btnShow_Click(object sender, EventArgs e)
{
String[] fruit = { "Appel", "Aardbei", "Banaan", "Framboos", "Mango" }; ;
foreach(String eten in fruit)
{
fruitList.Items.Add(eten);
}
Array.Sort(fruit);
}
private void btnClear_Click(object sender, EventArgs e)
{
fruitList.Items.Clear();
lblSelectedFruit.Text = "";
}
private void btnClose_Click(object sender, EventArgs e)
{
this.Close();
}
private void FruitList_SelectedIndexChanged(object sender, EventArgs e)
{
if (fruitList.SelectedIndices.Count > 0)
{
int selectedNumber = fruitList.SelectedIndices[0];
string selectedFruit = fruitList.Items[selectedNumber].Text;
lblSelectedFruit.Text = selectedFruit;
}
else
{
return;
}
}
}
}
|
bb511eb4813eb7d14fdd7be2f1ccfb70bb62dc60
|
C#
|
jebcat1982/healthvault-samples
|
/dotNETStandard/HealthVault.Mobile/cs/Xamarin.Core/ViewModels/DataTypeFormatter.cs
| 2.65625
| 3
|
using System;
using Microsoft.HealthVault.ItemTypes;
namespace HealthVault.Sample.Xamarin.Core.ViewModels
{
public static class DataTypeFormatter
{
public static DateTime EmptyDate { get; } = new DateTime(1900, 1, 1);
public static string ApproximateDateTimeToString(ApproximateDateTime medicationDateStarted)
{
var current = ApproximateDateTimeToDateTime(medicationDateStarted);
return current.ToString(System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortDatePattern);
}
public static DateTime ApproximateDateTimeToDateTime(ApproximateDateTime medicationDateStarted)
{
ApproximateDate date = medicationDateStarted?.ApproximateDate;
DateTime current;
if (date == null)
{
current = EmptyDate;
}
else
{
var year = date.Year;
var month = (date.Month != null) ? date.Month.Value : 1;
var day = (date.Day != null) ? date.Day.Value : 1;
current = new DateTime(year, month, day);
}
return current;
}
public static string FormatMedicationDetail(GeneralMeasurement medicationStrength, GeneralMeasurement medicationDose)
{
if (medicationStrength == null)
{
return medicationDose?.Display ?? "";
}
if (medicationDose == null)
{
return medicationStrength?.Display ?? "";
}
return $"{medicationStrength.Display}, {medicationDose.Display}";
}
}
}
|
a3fbaa19e8905e1a0109a4ec3407d118971d7998
|
C#
|
brian-reichle/Buffalo
|
/src/Buffalo.Core.Test/TestHelpers/Renderer.Lexer.cs
| 2.578125
| 3
|
// Copyright (c) Brian Reichle. 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.Text;
using Buffalo.Core.Lexer;
using Buffalo.Core.Lexer.Configuration;
namespace Buffalo.Core.Test
{
static partial class Renderer
{
public static string Render(ReElement element)
{
var builder = new StringBuilder();
Render(builder, 0, element);
return builder.ToString();
}
static void Render(StringBuilder builder, int indent, IEnumerable<ReElement> elements)
{
builder.AppendLine("new IReElement[]");
builder.Append(' ', indent);
builder.AppendLine("{");
foreach (var element in elements)
{
builder.Append(' ', indent + 1);
Render(builder, indent + 1, element);
builder.AppendLine(",");
}
builder.Append(' ', indent);
builder.Append("}");
}
static void Render(StringBuilder builder, int indent, ReElement element)
{
switch (element.Kind)
{
case ReElementKind.EmptyLanguage:
RenderReEmptyLanguage(builder);
break;
case ReElementKind.EmptyString:
RenderReEmptyString(builder);
break;
case ReElementKind.Singleton:
RenderReSingleton(builder, indent, (ReSingleton)element);
break;
case ReElementKind.KleenStar:
RenderReKleenStar(builder, indent, (ReKleeneStar)element);
break;
case ReElementKind.Concatenation:
RenderReConcatenation(builder, indent, (ReConcatenation)element);
break;
case ReElementKind.Union:
RenderReUnion(builder, indent, (ReUnion)element);
break;
default:
throw new InvalidOperationException("and what am i supposed to do with a '" + element.Kind + "'?");
}
}
static void RenderReSingleton(StringBuilder builder, int indent, ReSingleton element)
{
builder.Append("new ReSingleton(");
Render(builder, indent, element.Label);
builder.Append(")");
}
static void RenderReUnion(StringBuilder builder, int indent, ReUnion element)
{
builder.Append("new ReUnion(");
Render(builder, indent, element.Elements);
builder.Append(")");
}
static void RenderReKleenStar(StringBuilder builder, int indent, ReKleeneStar element)
{
builder.AppendLine("new ReKleeneStar");
builder.Append(' ', indent);
builder.AppendLine("(");
builder.Append(' ', indent + 1);
Render(builder, indent + 1, element.Element);
builder.AppendLine();
builder.Append(' ', indent);
builder.Append(")");
}
static void RenderReConcatenation(StringBuilder builder, int indent, ReConcatenation element)
{
builder.Append("new ReConcatenation(");
Render(builder, indent, element.Elements);
builder.Append(")");
}
static void RenderReEmptyLanguage(StringBuilder builder)
{
builder.Append("new ReEmptyLanguage()");
}
static void RenderReEmptyString(StringBuilder builder)
{
builder.Append("new ReEmptyString()");
}
public static string Render(IEnumerable<CharSet> charSetList)
{
var builder = new StringBuilder();
var list = new List<CharSet>(charSetList);
list.Sort(delegate (CharSet c1, CharSet c2)
{
return StringComparer.Ordinal.Compare(c1.ToString(), c2.ToString());
});
foreach (var set in list)
{
builder.AppendLine(set.ToString());
}
return builder.ToString();
}
static void Render(StringBuilder builder, int indent, CharSet set)
{
builder.Append("CharSet.New(");
var ranges = new List<CharRange>(set);
switch (ranges.Count)
{
case 0:
builder.Append("new CharRange[] { }");
break;
case 1:
builder.Append('\'');
AppendEscapedChar(builder, ranges[0].From);
if (ranges[0].To != ranges[0].From)
{
builder.Append("', '");
AppendEscapedChar(builder, ranges[0].To);
}
builder.Append("'");
break;
default:
builder.AppendLine("new CharRange[]");
builder.Append(' ', indent);
builder.AppendLine("{");
foreach (var range in ranges)
{
builder.Append(' ', indent + 1);
Render(builder, range);
builder.AppendLine(",");
}
builder.Append(' ', indent);
builder.Append("}");
break;
}
builder.Append(")");
}
static void Render(StringBuilder builder, CharRange range)
{
builder.Append("new CharRange('");
AppendEscapedChar(builder, range.From);
builder.Append("', '");
AppendEscapedChar(builder, range.To);
builder.Append("')");
}
public static string Render(IEnumerable<ConfigToken> tokens)
{
var builder = new StringBuilder();
Render(builder, 0, tokens);
return builder.ToString();
}
static void Render(StringBuilder builder, int indent, IEnumerable<ConfigToken> tokens)
{
builder.AppendLine("new ConfigToken[]");
builder.Append('\t', indent);
builder.AppendLine("{");
foreach (var token in tokens)
{
builder.Append('\t', indent + 1);
Render(builder, token);
builder.AppendLine(",");
}
builder.Append('\t', indent);
builder.Append("}");
}
static void Render(StringBuilder builder, ConfigToken token)
{
if (token == null)
{
builder.Append("null");
}
else
{
builder.Append("new ConfigToken(");
if (Enum.IsDefined(typeof(ConfigTokenType), token.Type))
{
builder.Append("ConfigTokenType.");
builder.Append(token.Type.ToString());
}
else
{
builder.Append("(int)(");
builder.Append((int)token.Type);
builder.Append(')');
}
builder.Append(", ");
Render(builder, token.FromPos);
builder.Append(", ");
Render(builder, token.ToPos);
builder.Append(", ");
AppendString(builder, token.Text);
builder.Append(')');
}
}
}
}
|
35c1778de0b5b0e7b8549eda043d7066abcde922
|
C#
|
ChrisPam/CSharpAdvanced
|
/08.ManualStringProcessingExercise/09.TextFilter/Program.cs
| 3.5
| 4
|
using System;
using System.Collections.Generic;
using System.Linq;
public class TextFilter
{
public static void Main()
{
var banWords = Console.ReadLine().Split(new string[] { ", " },
StringSplitOptions.RemoveEmptyEntries).OrderByDescending(x => x.Length).ToList();
var text = Console.ReadLine();
FilterText(banWords, text);
}
public static void FilterText(List<string> banWords, string text)
{
foreach (var banWord in banWords)
{
var hasBanWord = text.IndexOf(banWord);
while (hasBanWord >= 0)
{
text = text.Replace(banWord, new string('*', banWord.Length));
break;
}
}
Console.WriteLine(text);
}
}
|
e07a7604d90efcd76f363af37b757643ee5e429e
|
C#
|
Batooon/BadgeFactory
|
/Assets/Plugins/VoodooPackages/TinySauce/TinySauce.cs
| 2.625
| 3
|
using GameAnalyticsSDK;
using Voodoo.Sauce.Internal;
using Voodoo.Sauce.Internal.Analytics;
public static class TinySauce
{
public const string Version = "3.2.1";
/// <summary>
/// Method to call whenever the user starts a game.
/// </summary>
/// <param name="levelNumber">The game Level, this parameter is optional for game without level</param>
public static void OnGameStarted(string levelNumber = null)
{
AnalyticsManager.OnGameStarted(levelNumber);
}
/// <summary>
/// Method to call whenever the user completes a game.
/// </summary>
/// <param name="score">The score of the game</param>
public static void OnGameFinished(float score)
{
OnGameFinished(null, score);
}
/// <summary>
/// Method to call whenever the user completes a game with levels.
/// </summary>
/// <param name="levelNumber">The game Level</param>
/// <param name="score">The score of the game</param>
public static void OnGameFinished(string levelNumber, float score)
{
OnGameFinished(levelNumber,true, score);
}
/// <summary>
/// Method to call whenever the user finishes a game, even when leaving a game.
/// </summary>
/// <param name="levelNumber">The game Level</param>
/// <param name="levelComplete">Whether the user finished the game</param>
/// <param name="score">The score of the game</param>
public static void OnGameFinished(string levelNumber, bool levelComplete, float score)
{
AnalyticsManager.OnGameFinished(levelComplete, score, levelNumber, null);
}
/// <summary>
/// Call this method to track any custom event you want.
/// </summary>
/// <param name="eventName">The name of the event to track</param>
public static void TrackCustomEvent(string eventName)
{
AnalyticsManager.TrackCustomEvent(eventName);
}
/// <summary>
/// Call this method to track any custom event you want.
/// </summary>
/// <param name="eventName">The name of the event to track</param>
/// <param name="eventValue">Number value of event.</param>
public static void TrackCustomEvent(string eventName, float eventValue)
{
AnalyticsManager.TrackCustomEvent(eventName, eventValue);
}
}
|
935577475dc056b36b49d02458499fd714762e89
|
C#
|
hstefanov/Telerik-Academy-Tasks
|
/1. Programming/1. C# - Part One/01. Introduction-To-Programming/PrintSquareOfNumber/PrintSquareOfNumber.cs
| 3.015625
| 3
|
using System;
class PrintSquareOfNumber
{
static void Main()
{
int number = 12345;
Console.WriteLine("Square of {0} is {1} ",number,Math.Sqrt(number));
}
}
|
23cac25128809ef9adba4fd6476982a2470c277b
|
C#
|
Bimmr/DXBall---Brick-Breaker
|
/DXBall/Ball.cs
| 2.515625
| 3
|
using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Media;
namespace DXBall
{
public class Ball : DrawableGameComponent
{
private int paddleCoolDown;
private Game1 _game;
private SpriteBatch _spriteBatch;
private Vector2 _stage;
private Texture2D _texture2D;
private Vector2 _location;
private Vector2 _speed;
private Rectangle _srcRectangle;
private Rectangle _rectangle;
public Vector2 Location
{
get { return _location; }
set { _location = value; }
}
public float SpeedX
{
get { return _speed.X; }
set { _speed.X = value; }
}
public float SpeedY
{
get { return _speed.Y; }
set { _speed.Y = value; }
}
public Ball(Game1 game, SpriteBatch spriteBatch, Texture2D texture2D, Vector2 location, Vector2 stage)
: base(game)
{
_game = game;
_spriteBatch = spriteBatch;
_texture2D = texture2D;
_location = location;
_stage = stage;
_speed = new Vector2(5, -5);
_srcRectangle = new Rectangle(0, 0, _texture2D.Width, _texture2D.Height);
_rectangle = new Rectangle((int) _location.X, (int) _location.Y, (int)(_texture2D.Width*.75), (int)(_texture2D.Height*.75));
}
public Rectangle Rectangle
{
get { return _rectangle; }
set { _rectangle = value; }
}
public override void Initialize()
{
base.Initialize();
}
public override void Draw(GameTime gameTime)
{
_spriteBatch.Begin();
_spriteBatch.Draw(_texture2D, _rectangle, _srcRectangle, Color.White);
_spriteBatch.End();
}
public override void Update(GameTime gameTime)
{
_location += _speed;
//Hits Bottom
if (_rectangle.Bottom >= _stage.Y)
{
_game.Components.Remove(this);
//Lost
}
// Hits Right
if (_rectangle.Right >= _stage.X)
{
_speed.X = -Math.Abs(_speed.X);
_game.clickSound.Play();
}
//Hits Top
if (_rectangle.Top <= 0)
{
_speed.Y = Math.Abs(_speed.Y);
_game.clickSound.Play();
}
//Hits Left
if (_rectangle.Left <= 0)
{
_speed.X = Math.Abs(_speed.X);
_game.clickSound.Play();
}
_rectangle.X = (int) _location.X;
_rectangle.Y = (int) _location.Y;
//Hits Paddle
if (_rectangle.Intersects(_game.paddle.Rectangle))
{
_speed.Y = -Math.Abs(_speed.Y);
_game.clickSound.Play();
}
}
}
}
|
a8e8135dec047da8f045b3533c760a2eac14ddcb
|
C#
|
cangunfer/AspNetWebApi_Json
|
/AspMvcWebApi/Models/Database.cs
| 2.8125
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace AspMvcWebApi.Models
{
public static class Database
{
private static List<User> _database;
static Database()
{
_database=new List<User>(){
new User() {Id=1,Name="Mehmetcan",Age="23" },
new User() {Id=2,Name="Ahmet",Age="24" }
};
}
public static List<User>_Database
{
get { return _database; }
}
public static void AddUser(User entity)
{
_database.Add(entity);
}
}
}
|
16f24a3bdca4322aa6aff6f4bfef882583ce77ea
|
C#
|
JakeJP/jCryption.NET
|
/App_Code/jCryption.cs
| 2.765625
| 3
|
/*
* jCryption.NET v 1.3.3
* is a server side implementation for jCryption v3.0 and ASP.NET
* written by Jake.Y.Yoshimura
* https://github.com/JakeJP/jCryption.NET
*
* MIT license.
* http://www.opensource.org/licenses/mit-license.php
*
* jCryption client side library is originally created by Daniel Griesser:
* http://www.jcryption.org/
*
* Some SSL related methods are from http://www.jensign.com/opensslkey/opensslkey.cs
*/
using System;
using System.IO;
using System.Collections.Generic;
using System.Collections;
using System.Collections.Specialized;
using System.Text;
using System.Security.Cryptography;
using System.Web;
namespace jCryption
{
/// <summary>
/// Utilities from http://www.jensign.com/opensslkey/opensslkey.cs
/// </summary>
public static class Utility
{
// ----- Get the binary RSA PRIVATE key, decrypting if necessary ----
public static byte[] DecodeOpenSSLPrivateKey(String instr)
{
const String pemprivheader = "-----BEGIN RSA PRIVATE KEY-----";
const String pemprivfooter = "-----END RSA PRIVATE KEY-----";
String pemstr = instr.Trim();
byte[] binkey;
if (!pemstr.StartsWith(pemprivheader) || !pemstr.EndsWith(pemprivfooter))
return null;
StringBuilder sb = new StringBuilder(pemstr);
sb.Replace(pemprivheader, ""); //remove headers/footers, if present
sb.Replace(pemprivfooter, "");
String pvkstr = sb.ToString().Trim(); //get string after removing leading/trailing whitespace
try
{ // if there are no PEM encryption info lines, this is an UNencrypted PEM private key
binkey = Convert.FromBase64String(pvkstr);
return binkey;
}
catch (System.FormatException)
{ //if can't b64 decode, it must be an encrypted private key
//Console.WriteLine("Not an unencrypted OpenSSL PEM private key");
}
StringReader str = new StringReader(pvkstr);
//-------- read PEM encryption info. lines and extract salt -----
if (!str.ReadLine().StartsWith("Proc-Type: 4,ENCRYPTED"))
return null;
String saltline = str.ReadLine();
if (!saltline.StartsWith("DEK-Info: DES-EDE3-CBC,"))
return null;
String saltstr = saltline.Substring(saltline.IndexOf(",") + 1).Trim();
byte[] salt = new byte[saltstr.Length / 2];
for (int i = 0; i < salt.Length; i++)
salt[i] = Convert.ToByte(saltstr.Substring(i * 2, 2), 16);
if (!(str.ReadLine() == ""))
return null;
//------ remaining b64 data is encrypted RSA key ----
String encryptedstr = str.ReadToEnd();
try
{ //should have b64 encrypted RSA key now
binkey = Convert.FromBase64String(encryptedstr);
}
catch (System.FormatException)
{ // bad b64 data.
return null;
}
// does not support encrypted private key
throw new NotImplementedException();
#if false
//------ Get the 3DES 24 byte key using PDK used by OpenSSL ----
SecureString despswd = GetSecPswd("Enter password to derive 3DES key==>");
//Console.Write("\nEnter password to derive 3DES key: ");
//String pswd = Console.ReadLine();
byte[] deskey = GetOpenSSL3deskey(salt, despswd, 1, 2); // count=1 (for OpenSSL implementation); 2 iterations to get at least 24 bytes
if (deskey == null)
return null;
//showBytes("3DES key", deskey) ;
//------ Decrypt the encrypted 3des-encrypted RSA private key ------
byte[] rsakey = DecryptKey(binkey, deskey, salt); //OpenSSL uses salt value in PEM header also as 3DES IV
if (rsakey != null)
return rsakey; //we have a decrypted RSA private key
else
{
Console.WriteLine("Failed to decrypt RSA private key; probably wrong password.");
return null;
}
#endif
}
//-------- Get the binary RSA PUBLIC key --------
public static byte[] DecodeOpenSSLPublicKey(String instr)
{
const String pempubheader = "-----BEGIN PUBLIC KEY-----";
const String pempubfooter = "-----END PUBLIC KEY-----";
String pemstr = instr.Trim();
byte[] binkey;
if (!pemstr.StartsWith(pempubheader) || !pemstr.EndsWith(pempubfooter))
return null;
StringBuilder sb = new StringBuilder(pemstr);
sb.Replace(pempubheader, ""); //remove headers/footers, if present
sb.Replace(pempubfooter, "");
String pubstr = sb.ToString().Trim(); //get string after removing leading/trailing whitespace
try
{
binkey = Convert.FromBase64String(pubstr);
}
catch (System.FormatException)
{ //if can't b64 decode, data is not valid
return null;
}
return binkey;
}
private static int GetIntegerSize(BinaryReader binr)
{
byte bt = 0;
byte lowbyte = 0x00;
byte highbyte = 0x00;
int count = 0;
bt = binr.ReadByte();
if (bt != 0x02) //expect integer
return 0;
bt = binr.ReadByte();
if (bt == 0x81)
count = binr.ReadByte(); // data size in next byte
else
if (bt == 0x82)
{
highbyte = binr.ReadByte(); // data size in next 2 bytes
lowbyte = binr.ReadByte();
byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };
count = BitConverter.ToInt32(modint, 0);
}
else
{
count = bt; // we already have the data size
}
while (binr.ReadByte() == 0x00)
{ //remove high order zeros in data
count -= 1;
}
binr.BaseStream.Seek(-1, SeekOrigin.Current); //last ReadByte wasn't a removed zero, so back up a byte
return count;
}
public static RSAParameters DecodeRSAPrivateKey(byte[] privkey)
{
byte[] MODULUS, E, D, P, Q, DP, DQ, IQ;
// --------- Set up stream to decode the asn.1 encoded RSA private key ------
MemoryStream mem = new MemoryStream(privkey);
BinaryReader binr = new BinaryReader(mem); //wrap Memory Stream with BinaryReader for easy reading
byte bt = 0;
ushort twobytes = 0;
int elems = 0;
try
{
twobytes = binr.ReadUInt16();
if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
binr.ReadByte(); //advance 1 byte
else if (twobytes == 0x8230)
binr.ReadInt16(); //advance 2 bytes
else
throw new InvalidDataException();//return null;
twobytes = binr.ReadUInt16();
if (twobytes != 0x0102) //version number
throw new InvalidDataException(); //return null;
bt = binr.ReadByte();
if (bt != 0x00)
throw new InvalidDataException(); //return null;
//------ all private key components are Integer sequences ----
elems = GetIntegerSize(binr);
MODULUS = binr.ReadBytes(elems);
elems = GetIntegerSize(binr);
E = binr.ReadBytes(elems);
elems = GetIntegerSize(binr);
D = binr.ReadBytes(elems);
elems = GetIntegerSize(binr);
P = binr.ReadBytes(elems);
elems = GetIntegerSize(binr);
Q = binr.ReadBytes(elems);
elems = GetIntegerSize(binr);
DP = binr.ReadBytes(elems);
elems = GetIntegerSize(binr);
DQ = binr.ReadBytes(elems);
elems = GetIntegerSize(binr);
IQ = binr.ReadBytes(elems);
// ------- create RSACryptoServiceProvider instance and initialize with public key -----
RSAParameters RSAparams = new RSAParameters();
RSAparams.Modulus = MODULUS;
RSAparams.Exponent = E;
RSAparams.D = D;
RSAparams.P = P;
RSAparams.Q = Q;
RSAparams.DP = DP;
RSAparams.DQ = DQ;
RSAparams.InverseQ = IQ;
return RSAparams;
}
catch (Exception)
{
throw new InvalidDataException(); //return null;
}
finally
{
binr.Close();
}
}
public static String CreateRSAPublicKeyPEM(RSAParameters parameters)
{
List<byte> arrBinaryPublicKey = new List<byte>();
var eList = new List<byte>(parameters.Exponent); CalculateAndAppendLength(eList); eList.Insert(0, 0x02);// INTEGER
var nList = new List<byte>(parameters.Modulus); CalculateAndAppendLength(nList); nList.Insert(0, 0x02); // INTEGER
arrBinaryPublicKey.AddRange(nList); arrBinaryPublicKey.AddRange(eList);
CalculateAndAppendLength(arrBinaryPublicKey); arrBinaryPublicKey.Insert(0, 0x30); // SEQUENCE = 0x30
arrBinaryPublicKey.Insert(0, 0x00); // ( number of unused bits that exist in the last content byte )
CalculateAndAppendLength(arrBinaryPublicKey); arrBinaryPublicKey.Insert(0, 0x03); // BIT STRING = 3
// Oid
arrBinaryPublicKey.InsertRange(0, new byte[] { 0x30, 0xD, 0x6, 0x9, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0xD, 0x1, 0x1, 0x1, 0x5, 0x0 } /* Object ID for RSA The oid for RSA keys is 1.2.840.113549.1.1.1. */);
CalculateAndAppendLength(arrBinaryPublicKey);
arrBinaryPublicKey.Insert(0, 0x30); // SEQUENCE
//End Transformation
StringBuilder sb = new StringBuilder();
sb.AppendLine("-----BEGIN PUBLIC KEY-----")
.AppendLine(System.Convert.ToBase64String(arrBinaryPublicKey.ToArray(), Base64FormattingOptions.InsertLineBreaks))
.AppendLine("-----END PUBLIC KEY-----");
return sb.ToString();
}
private static void CalculateAndAppendLength(List<byte> arrBinaryData)
{
int nLen;
nLen = arrBinaryData.Count;
if (nLen <= byte.MaxValue)
{
arrBinaryData.Insert(0, Convert.ToByte(nLen));
arrBinaryData.Insert(0, 0x81); //This byte means that the length fits in one byte
}
else
{
arrBinaryData.Insert(0, Convert.ToByte(nLen % (byte.MaxValue + 1)));
arrBinaryData.Insert(0, Convert.ToByte(nLen / (byte.MaxValue + 1)));
arrBinaryData.Insert(0, 0x82); //This byte means that the length fits in two byte
}
}
const String SessionKeyStoreKey = "jcryption_aes_key";
public static void ProcessRequest(HttpContextBase context, RSACryptoServiceProvider cryptoProvider)
{
if (context.Request.IsSecureConnection) return;
var Request = context.Request; var Response = context.Response; var Session = context.Session;
var conv = new System.Web.Script.Serialization.JavaScriptSerializer();
if (Request.QueryString["getPublicKey"] != null)
{
Response.Cache.SetNoStore();
var parameter = cryptoProvider.ExportParameters(false);
Response.Write(conv.Serialize(new { publickey = Utility.CreateRSAPublicKeyPEM(parameter) }));
Response.ContentType = "application/json";
Response.End();
}
else if (Request.QueryString["handshake"] != null)
{
var key = Convert.FromBase64String(Request.Form["key"]);
var keyDecrypted = cryptoProvider.Decrypt(key, false);
Session[SessionKeyStoreKey] = keyDecrypted;
byte[] saltBytes = new byte[8];
System.Buffer.BlockCopy(keyDecrypted, 0, saltBytes, 0, 8);
byte[] toBeEncrypted = new byte[keyDecrypted.Length - 8];
System.Buffer.BlockCopy(keyDecrypted, 0, toBeEncrypted, 0, keyDecrypted.Length - 8);
var kd = new OpenSslCompatDeriveBytes(keyDecrypted, saltBytes, "MD5", 1);// new Rfc2898DeriveBytes(keyDecrypted, saltBytes, 1000);
var aesProvider = new AesCryptoServiceProvider() { KeySize = 256, BlockSize = 128, Mode = CipherMode.CBC };
var encrypter = aesProvider.CreateEncryptor(kd.GetBytes(aesProvider.KeySize / 8), kd.GetBytes(aesProvider.BlockSize / 8));
using (var ms = new System.IO.MemoryStream())
using (var writer = new System.IO.BinaryWriter(ms))
{
writer.Write(Encoding.ASCII.GetBytes("Salted__"));
writer.Write(saltBytes);
writer.Write(encrypter.TransformFinalBlock(keyDecrypted, 0, keyDecrypted.Length));
writer.Flush();
Response.Write(conv.Serialize(new
{
challenge = Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length)
}));
}
Response.ContentType = "application/json";
Response.Cache.SetNoStore();
Response.End();
}
else if (Request.QueryString["decode"] != null)
{
var data = System.Web.Security.MachineKey.Decode(Request.Form["data"], System.Web.Security.MachineKeyProtection.All);
byte[] keyDecrypted = Request.Form["jCryptionKey"] != null ? cryptoProvider.Decrypt(Convert.FromBase64String(Request.Form["jCryptionKey"]), false) : (byte[])Session[SessionKeyStoreKey];
if (keyDecrypted == null)
{
Response.StatusCode = 412;
Response.End();
}
byte[] saltBytes = new byte[8];
System.Buffer.BlockCopy(keyDecrypted, 0, saltBytes, 0, 8);
byte[] toBeEncrypted = new byte[keyDecrypted.Length - 8];
System.Buffer.BlockCopy(keyDecrypted, 0, toBeEncrypted, 0, keyDecrypted.Length - 8);
var kd = new OpenSslCompatDeriveBytes(keyDecrypted, saltBytes, "MD5", 1);// new Rfc2898DeriveBytes(keyDecrypted, saltBytes, 1000);
var aesProvider = new AesCryptoServiceProvider() { KeySize = 256, BlockSize = 128, Mode = CipherMode.CBC };
var encrypter = aesProvider.CreateEncryptor(kd.GetBytes(aesProvider.KeySize / 8), kd.GetBytes(aesProvider.BlockSize / 8));
using (var ms = new System.IO.MemoryStream())
using (var writer = new System.IO.BinaryWriter(ms))
{
writer.Write(Encoding.ASCII.GetBytes("Salted__"));
writer.Write(saltBytes);
writer.Write(encrypter.TransformFinalBlock(data, 0, data.Length));
writer.Flush();
Response.Write(conv.Serialize(new
{
data = Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length)
}));
}
Response.ContentType = "application/json";
Response.Cache.SetNoStore();
Response.End();
}
else if (Request.Form["jCryption"] != null)
{
NameValueCollection tempForm;
byte[] keyDecrypted = Request.Form["jCryptionKey"] != null ? cryptoProvider.Decrypt(Convert.FromBase64String(Request.Form["jCryptionKey"]), false) : (byte[])Session[SessionKeyStoreKey];
if (keyDecrypted == null)
{
Response.StatusCode = 412;
Response.End();
}
var jCryption = Convert.FromBase64String(Request.Form["jCryption"]);
var reader = new System.IO.BinaryReader(new System.IO.MemoryStream(jCryption));
var saltMark = reader.ReadBytes(8);
var saltBytes = reader.ReadBytes(8);
var kd = new OpenSslCompatDeriveBytes(keyDecrypted, saltBytes, "MD5", 1);
var aesProvider = new AesCryptoServiceProvider();
var decryptor = aesProvider.CreateDecryptor(kd.GetBytes(aesProvider.KeySize / 8), kd.GetBytes(aesProvider.BlockSize / 8));
using (var cs = new CryptoStream(reader.BaseStream, decryptor, CryptoStreamMode.Read))
using (var sr = new StreamReader(cs))
{
tempForm = HttpUtility.ParseQueryString(sr.ReadToEnd());
}
foreach (NameValueCollection collection in new[] { Request.Form, System.Web.Helpers.Validation.Unvalidated(Request).Form })
{
// Get the "IsReadOnly" protected instance property.
var propInfo = collection.GetType().GetProperty("IsReadOnly", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
// Mark the collection as NOT "IsReadOnly"
propInfo.SetValue(collection, false, new object[] { });
foreach (var k in tempForm.AllKeys)
{
collection[k] = tempForm[k];
}
propInfo.SetValue(collection, true, new object[] { });
}
}
}
}
/// <summary>
/// Derives a key from a password using an OpenSSL-compatible version of the PBKDF1 algorithm.
/// </summary>
/// <remarks>
/// based on the OpenSSL EVP_BytesToKey method for generating key and iv
/// http://www.openssl.org/docs/crypto/EVP_BytesToKey.html
/// </remarks>
public class OpenSslCompatDeriveBytes : DeriveBytes
{
private readonly byte[] _data;
private readonly HashAlgorithm _hash;
private readonly int _iterations;
private readonly byte[] _salt;
private byte[] _currentHash;
private int _hashListReadIndex;
private List<byte> _hashList;
/// <summary>
/// Initializes a new instance of the <see cref="OpenSslCompat.OpenSslCompatDeriveBytes"/> class specifying the password, key salt, hash name, and iterations to use to derive the key.
/// </summary>
/// <param name="password">The password for which to derive the key.</param>
/// <param name="salt">The key salt to use to derive the key.</param>
/// <param name="hashName">The name of the hash algorithm for the operation. (e.g. MD5 or SHA1)</param>
/// <param name="iterations">The number of iterations for the operation.</param>
public OpenSslCompatDeriveBytes(string password, byte[] salt, string hashName, int iterations)
: this(new UTF8Encoding(false).GetBytes(password), salt, hashName, iterations)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="OpenSslCompat.OpenSslCompatDeriveBytes"/> class specifying the password, key salt, hash name, and iterations to use to derive the key.
/// </summary>
/// <param name="password">The password for which to derive the key.</param>
/// <param name="salt">The key salt to use to derive the key.</param>
/// <param name="hashName">The name of the hash algorithm for the operation. (e.g. MD5 or SHA1)</param>
/// <param name="iterations">The number of iterations for the operation.</param>
public OpenSslCompatDeriveBytes(byte[] password, byte[] salt, string hashName, int iterations)
{
if (iterations <= 0)
throw new ArgumentOutOfRangeException("iterations", iterations, "iterations is out of range. Positive number required");
_data = password;
_salt = salt;
_hash = HashAlgorithm.Create(hashName);
_iterations = iterations;
}
/// <summary>
/// Returns a pseudo-random key from a password, salt and iteration count.
/// </summary>
/// <param name="cb">The number of pseudo-random key bytes to generate.</param>
/// <returns>A byte array filled with pseudo-random key bytes.</returns>
public override byte[] GetBytes(int cb)
{
if (cb <= 0)
throw new ArgumentOutOfRangeException("cb", cb, "cb is out of range. Positive number required.");
if (_currentHash == null)
{
_hashList = new List<byte>();
_currentHash = new byte[0];
_hashListReadIndex = 0;
int preHashLength = _data.Length + ((_salt != null) ? _salt.Length : 0);
var preHash = new byte[preHashLength];
System.Buffer.BlockCopy(_data, 0, preHash, 0, _data.Length);
if (_salt != null)
System.Buffer.BlockCopy(_salt, 0, preHash, _data.Length, _salt.Length);
_currentHash = _hash.ComputeHash(preHash);
for (int i = 1; i < _iterations; i++)
{
_currentHash = _hash.ComputeHash(_currentHash);
}
_hashList.AddRange(_currentHash);
}
while (_hashList.Count < (cb + _hashListReadIndex))
{
int preHashLength = _currentHash.Length + _data.Length + ((_salt != null) ? _salt.Length : 0);
var preHash = new byte[preHashLength];
System.Buffer.BlockCopy(_currentHash, 0, preHash, 0, _currentHash.Length);
System.Buffer.BlockCopy(_data, 0, preHash, _currentHash.Length, _data.Length);
if (_salt != null)
System.Buffer.BlockCopy(_salt, 0, preHash, _currentHash.Length + _data.Length, _salt.Length);
_currentHash = _hash.ComputeHash(preHash);
for (int i = 1; i < _iterations; i++)
{
_currentHash = _hash.ComputeHash(_currentHash);
}
_hashList.AddRange(_currentHash);
}
byte[] dst = new byte[cb];
_hashList.CopyTo(_hashListReadIndex, dst, 0, cb);
_hashListReadIndex += cb;
return dst;
}
/// <summary>
/// Resets the state of the operation.
/// </summary>
public override void Reset()
{
_hashListReadIndex = 0;
_currentHash = null;
_hashList = null;
}
}
/// <summary>
/// ASPX page
/// </summary>
public class SecurePage : System.Web.UI.Page
{
#if true // case for automatically created RSA key ( recommended )
static RSACryptoServiceProvider cryptoProvider = new RSACryptoServiceProvider(1024);
#elif true // using .NET style exported RSA key in XML format
String rsa_1024_pub_xml = "~/App_Data/rsa_1024_pub.xml";
String rsa_1024_priv_xml = "~/App_Data/rsa_1024_priv.xml";
RSACryptoServiceProvider _cryptoProvider = null;
RSACryptoServiceProvider cryptoProvider {
get
{
if( _cryptoProvider == null ){
_cryptoProvider = new RSACryptoServiceProvider();
_cryptoProvider.FromXmlString(System.IO.File.ReadAllText(Server.MapPath(rsa_1024_priv_xml)));
}
return _cryptoProvider;
}
}
#else // using OpenSSL exprted pem file (as written in the original PHP implementation)
String rsa_1024_pub = "rsa_1024_pub.pem";
String rsa_1024_priv = "rsa_1024_priv.pem";
RSACryptoServiceProvider _cryptoProvider = null;
RSACryptoServiceProvider cryptoProvider
{
get
{
if (_cryptoProvider == null)
{
var pemBytes = Utility.DecodeOpenSSLPrivateKey(System.IO.File.ReadAllText(Server.MapPath("./" + rsa_1024_priv)));
_cryptoProvider = new RSACryptoServiceProvider();
_cryptoProvider.ImportParameters( Utility.DecodeRSAPrivateKey(pemBytes) );
}
return _cryptoProvider;
}
}
#endif
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
if( ! Request.IsSecureConnection )
Utility.ProcessRequest(new HttpContextWrapper(Context), cryptoProvider);
}
}
/// <summary>
/// ASP.NET WebPages helper library
/// </summary>
public static class jCryption
{
static private RSACryptoServiceProvider _cp = null;
static private readonly object _cpLock = new object();
static RSACryptoServiceProvider cryptoProvider {
get
{
if (_cp != null) return _cp;
lock (_cpLock)
{
_cp = new RSACryptoServiceProvider(1024);
}
return _cp;
}
}
/// <summary>
/// declare to handle request to respond to RSA public key exchange.
/// This method call should be placed on top of cshtml.
/// </summary>
/// <param name="request">WePages' Request object</param>
public static void HandleRequest(HttpRequestBase request, String serviceUrl = null )
{
request.RequestContext.HttpContext.Items[jCryptionServiceUrlKey] = serviceUrl ?? new Uri(request.Url, request.RawUrl).LocalPath;
global::jCryption.Utility.ProcessRequest(request.RequestContext.HttpContext, cryptoProvider);
}
/// <summary>
/// renders a script block to call $.jCryption activation with a formSelector
/// </summary>
/// <example>
/// @jCryptionScriptForm("form#login")
/// </example>
/// <param name="formSelector">jQuery selector, which specifies the 'form' element.</param>
/// <returns></returns>
public static IHtmlString RenderScriptFor(String formSelector, String src = null, IHtmlString script = null )
{
if (!Enabled) return null;
var sb = new StringBuilder();
if (script != null) sb.Append(script.ToHtmlString());
if (!String.IsNullOrEmpty(src)) sb.Append(@"<script type=""text/javascript"" src=""" + src + @"""></script>");
if (!String.IsNullOrEmpty(src) || script != null )
{
sb.Append(@"
<script type=""text/javascript"">
// tweak for compatibility with jquery.validate
(function($){
var _jCryption = $.jCryption;
var jCryptionMod = function(el,options){
var form = $(el), hasValidator = !!form.data('validator');
if (hasValidator) {
var v = form.validate();
var prev_handler = v.settings.submitHandler;
v.settings.submitHandler = function (_form, event) {
if( prev_handler ) prev_handler.apply(this, arguments);
var form = $(_form);
if (!form.hasClass('jc-before-submit')) {
v.settings.submitHandler = prev_handler;
form.addClass('jc-before-submit');
setTimeout( function(){ form.trigger('_jc_submit', event); }, 100 );
}
};
_jCryption.call(this, form, $.extend( options, {
submitElement: form,
submitEvent: '_jc_submit',
beforeEncryption: function(){
form.removeAttr('disabled');// form element hack ( IE11 )
return true;
}
}));
} else {
return _jCryption.call(this,el,options);
}
}
$.extend(jCryptionMod, $.jCryption);
$.jCryption = jCryptionMod;
})(jQuery);
</script>");
}
if (!String.IsNullOrEmpty(formSelector))
{
var path = ServiceUrl;
sb.Append(@"
<script type=""text/javascript"">
$(document).ready(function(){
var form = $('" + formSelector + @"');
var url = form.attr('action') || '" + path + @"';
form.jCryption({
getKeysURL: url + '?getPublicKey=true',
handshakeURL: url + '?handshake=true'
});
});
</script>");
}
return new HtmlString(sb.ToString());
}
private const String jCryptionFormDataKey = "__jcryption_form_data__";
private const String jCryptionEnabledKey = "__jcryption_enabled__";
private const String jCryptionServiceUrlKey = "__jcryption_service_url__";
public static bool Enabled
{
get {
if (!HttpContext.Current.Items.Contains(jCryptionEnabledKey))
{
HttpContext.Current.Items[jCryptionEnabledKey] = !HttpContext.Current.Request.IsSecureConnection;
}
return (bool)HttpContext.Current.Items[jCryptionEnabledKey];
}
set {
HttpContext.Current.Items[jCryptionEnabledKey] = value;
}
}
public static String ServiceUrl
{
get
{
return HttpContext.Current.Items.Contains(jCryptionServiceUrlKey) ? (String)HttpContext.Current.Items[jCryptionServiceUrlKey] : HttpContext.Current.Request.Path;
}
}
private static void AddFormNameValue(String name, String value)
{
var data = (Dictionary<String, String>)HttpContext.Current.Items[jCryptionFormDataKey];
if (data == null)
{
data = new Dictionary<String,String>();
HttpContext.Current.Items[jCryptionFormDataKey] = data;
}
var n = System.Web.HttpUtility.UrlPathEncode(name);
var v = System.Web.HttpUtility.UrlPathEncode(value);
if (data.ContainsKey(n)) data[n] = data[n] + "," + v;
else data[n] = v;
}
public static IHtmlString SecureNameValue(String name, String value )
{
if (!Enabled)
return new HtmlString(@"name=""" + HttpUtility.HtmlEncode(name) + @""" value=""" + HttpUtility.HtmlEncode(value) + @"""" );
else
{
AddFormNameValue(name, value);
return new HtmlString(@"name=""" + HttpUtility.HtmlEncode(name) + @""" data-jcryption-item=""true""" );
}
}
public static IHtmlString SecureNameValueCheck(String name, String value, bool check = false)
{
if (!Enabled)
return new HtmlString(@"name=""" + HttpUtility.HtmlEncode(name) + @""" value=""" + HttpUtility.HtmlEncode(value) + @"""" + (check ? " checked" : "") );
else
{
if (check) AddFormNameValue(name, value);
return new HtmlString(@"name=""" + HttpUtility.HtmlEncode(name) + @""" value=""" + HttpUtility.HtmlEncode(value) + @""" data-jcryption-item=""true""");
}
}
public static IHtmlString LoadSecureContents()
{
if (!Enabled) return new HtmlString(String.Empty);
var path = ServiceUrl;
var sb = new StringBuilder(
@"<script type=""text/javascript"">
$(document).ready(function () {
function escapeRegExp(str) {
return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, ""\\$&"");
}
var url = '" + path + @"';
var form = $('<form>');
form.jCryption({ getKeysURL: url + '?getPublicKey=true',handshakeURL: url + '?handshake=true' });");
var data = (Dictionary<String, String>)HttpContext.Current.Items[jCryptionFormDataKey];
sb.Append("var formdata = ");
if (data != null && data.Count > 0){
sb.Append(@"'")
.Append( System.Web.Security.MachineKey.Encode(Encoding.UTF8.GetBytes(new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(data)), System.Web.Security.MachineKeyProtection.All) )
.Append(@"';");
} else { sb.Append("null;"); }
sb.Append(@"
form.data('jCryption').authenticate(function (AESKey) {
$.jCryption.encryptKey(AESKey, function(AESEncryptedKey) {
// load secure contents
$('[data-jcryption-content]').each( function(){
var $target = $(this);
var data = $target.data('jcryptionData');
$.ajax({
url: url + '?decode=true',
dataType: 'json',
type: 'POST',
data: {
data: data, key: AESEncryptedKey
},
success: function (response) {
var html = decodeURIComponent($.jCryption.decrypt(response.data, AESKey));
$target.html(html);
}
});
});
// load secure form
if( formdata ){
$('form').filter(function () { return !!$(this).data('jCryption'); }).each(function(){
var $form = $(this);
$form.find('[data-jcryption-item]').prop('disabled', true );
$.ajax({
url: url + '?decode=true',
dataType: 'json',
type: 'POST',
data: {
data: formdata, key: AESEncryptedKey
},
success: function (response) {
var json = $.jCryption.decrypt(response.data, AESKey), data = $.parseJSON(json);
for (var n in data) {
var val = data[n];
if( val == null ) continue;
val = decodeURIComponent( val );
n = decodeURIComponent( n );
$form.find('*[name=""' + n + '""]').each(function () {
var e = $(this);
if (e.is('[type=checkbox],[type=radio]')) {
var ov = e.attr('value');
if ( ov == val || new RegExp( '(^|,)' + escapeRegExp(ov) + '($|,)' ).test(val) ) {
e.prop('checked', true);
}
} else if (e.is('select[multiple]')) {
e.find('option[value]').each(function () {
var ee = $(this), ov = ee.attr('value');
if ( ov == val || new RegExp( '(^|,)' + escapeRegExp(ov) + '($|,)' ).test(val) ) {
ee.prop('selected', true);
}
});
} else {
e.val(val);
}
});
}
$form.find('[data-jcryption-item]').prop('disabled', false );
}
});
});
}
});
}, function() {
// Authentication failed
});");
sb.Append(@"});</script>");
return new HtmlString(sb.ToString());
}
private static IHtmlString SecureContent(String html, String textType = "html")
{
return new HtmlString("<div data-jcryption-content='" + textType + "' data-jcryption-data='" +
System.Web.Security.MachineKey.Encode(System.Text.Encoding.UTF8.GetBytes(HttpUtility.UrlPathEncode(textType == "html"
? html
: HttpUtility.HtmlEncode(html))), System.Web.Security.MachineKeyProtection.All) + "'></div>");
}
public static IHtmlString SecureHtml( String html )
{
if (HttpContext.Current.Request.IsSecureConnection) return new HtmlString(html);
return SecureContent(html, "html");
}
public static IHtmlString SecureText(String text)
{
if (HttpContext.Current.Request.IsSecureConnection) return new HtmlString( HttpUtility.HtmlEncode( text ) );
return SecureContent( text, "text");
}
}
}
|
26c6a34eaae885310de88b3f9571a1b84e150db3
|
C#
|
vishvajit79/COMP3064_FINALPROJECT
|
/Assets/Scripts/Player.cs
| 2.859375
| 3
|
using UnityEngine;
public class Player {
//public variable
public CanvasController CanvasController;
//private variables
private int _score;
private int _life = 2;
private int _highScore;
private int _timer = 20;
private static Player _instance; //declaring player instance
//getter of player instance
public static Player Instance
{
get
{
if (_instance == null)
{
_instance = new Player();
}
return _instance;
}
}
//getter setter for score
public int Score
{
get { return _score; }
set
{
_score = value;
CanvasController.UpdateUi();
if (_score > _highScore)
{
_highScore = _score;
PlayerPrefs.SetInt("highScore", _highScore);
CanvasController.UpdateUi();
}
}
}
//getter setter for highscore
public int HighScore
{
get { return _highScore; }
set
{
_highScore = value;
//if current score is greater than previous high score, then sets high score to current score
if (_score > _highScore)
{
_highScore = _score;
CanvasController.UpdateUi();
}
//sets highscore
PlayerPrefs.SetInt("highScore", _highScore);
CanvasController.UpdateUi();
}
}
public int Timer
{
get { return _timer; }
set
{
_timer = value;
CanvasController.UpdateUi();
if (_timer <= 0)
{
CanvasController.PlayLifeDecreaseSound();
Instance.Life--;
Instance.Timer = 30;
CanvasController.UpdateUi();
}
}
}
//getter setter for life
public int Life
{
get { return _life; }
set
{
_life = value;
if (_life <= 0)
{
//game over
_highScore = _score;
CanvasController.UpdateUi();
CanvasController.GameOver();
}
else
{
//lifeLabel.text = "Life: " + _life;
CanvasController.UpdateUi();
}
}
}
}
|
d2d0f809a8d979a9d7ca5b793c014d410b4e1782
|
C#
|
artursolekss/sessionExamples
|
/BasicsExamples/StringExamples.cs
| 3.0625
| 3
|
using System;
namespace Basics
{
class StringExamples
{
static void Main(string[] args)
{
string testStrA = "Part";
string testStrB = "Part1";
string testAdd = "1";
// testStrA = testStrA + testStrB;
testStrA += "1";
Console.WriteLine(testStrA.Equals(testStrB));
}
}
}
|
be018c50d4658b59124eda6cb530743e61f254e5
|
C#
|
agaddampalli/Algorithms
|
/Chapter 2 - Arrays/ReorderLogFiles.linq
| 3.234375
| 3
|
<Query Kind="Program" />
void Main()
{
var input = new string[] {"a1 9 2 3 1","g1 act car","zo4 4 7","ab1 off key dog","a8 act zoo"};
ReorderLogFiles(input).Dump();
}
public string[] ReorderLogFiles(string[] logs)
{
Sort(0, logs.Length-1, logs);
return logs;
}
public void Sort(int start, int end, string[] logs)
{
if(start < end)
{
var mid = (start + end) / 2;
Sort(start, mid, logs);
Sort(mid + 1, end, logs);
Merge(start, mid, end, logs);
}
}
public void Merge(int start, int mid, int end, string[] logs)
{
var leftArray = new string[mid - start + 1];
var rightArray = new string[end - mid];
Array.Copy(logs, start, leftArray, 0, mid - start + 1);
Array.Copy(logs, mid + 1, rightArray, 0, end - mid);
int x = 0;
int y = 0;
for (int i = start; i < end + 1; i++)
{
if (x == leftArray.Length)
{
logs[i] = rightArray[y];
y++;
}
else if (y == rightArray.Length)
{
logs[i] = leftArray[x];
x++;
}
else if (IsLesser(leftArray[x], rightArray[y]))
{
logs[i] = leftArray[x];
x++;
}
else
{
logs[i] = rightArray[y];
y++;
}
}
}
public bool IsLesser(string left, string right)
{
var leftArray = left.Split(new char[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);
var rightArray = right.Split(new char[] {' ', ','}, StringSplitOptions.RemoveEmptyEntries);
var leftCondition = leftArray.Length > 1 && leftArray[1].Length > 0 && leftArray[1][0] > 47 && leftArray[1][0] < 58;
var rightCOndition = rightArray.Length > 1 && rightArray[1].Length > 0 && rightArray[1][0] > 47 && rightArray[1][0] < 58;
if(leftCondition && rightCOndition)
{
return true;
}
else if(leftCondition)
{
return false;
}
else if(rightCOndition)
{
return true;
}
int i =1;
int j =1;
while(i< leftArray.Length || j < rightArray.Length)
{
var leftString = i < leftArray.Length ? leftArray[i++] : null;
var rightString = j < rightArray.Length ? rightArray[j++] : null;
var result = string.Compare(leftString, rightString);
if(result == -1)
{
return true;
}
else if(result == 1)
{
return false;
}
}
var result1 = string.Compare(leftArray[0], rightArray[0]);
if (result1 <= 0)
{
return true;
}
else
{
return false;
}
}
|
7adfb1b56fb703da1e483cb8866cf429bdf8f92a
|
C#
|
holicoweve/kata-StringAverage
|
/StringAverage/Extensions.cs
| 3.546875
| 4
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
namespace Solution
{
public static class Extensions
{
private static readonly string[] Words = new string[]
{
"zero", "one", "two", "three", "four", "five",
"six", "seven", "eight", "nine"
};
public static int TextToInt(this string input)
{
if(Words.Contains(input)!=true)
throw new ArgumentOutOfRangeException();
return Array.IndexOf(Words, input);
}
public static string IntToText(this int input)
{
if (input < 0 || input > Words.Length - 1)
throw new AbandonedMutexException();
return Words[input];
}
}
}
|
8ddc877f98273dcb78f98589ecb246aa80161adb
|
C#
|
elmahalawym/ProblemSolving
|
/LeetCode/15_3Sum.cs
| 3.515625
| 4
|
public class Solution {
public IList<IList<int>> ThreeSum(int[] nums) {
var result = new List<IList<int>>();
Array.Sort(nums);
for(int i=0; i<nums.Length; i++) {
if(i>0 && nums[i] == nums[i-1])
continue;
int l = i+1, r=nums.Length-1;
while(r > l) {
int sum = nums[i] + nums[r] + nums[l];
if(sum > 0)
r--;
else if(sum < 0)
l++;
else{
result.Add(new [] { nums[i], nums[r], nums[l] });
while(l < r && nums[l] == nums[l+1])
l++;
while(l < r && nums[r] == nums[r-1])
r--;
l++;
r--;
}
}
}
return result;
}
}
|
e221fc8a24d310241480235c629693b17ea82a9f
|
C#
|
greck2908/DataStructures
|
/C#/Leetcode/String/CompareVersionNumbers.cs
| 3.78125
| 4
|
using System;
namespace LeetcodeSolutions.String
{
// Leetcdoe 165 - https://leetcode.com/problems/compare-version-numbers/description/
// Submission Detail - https://leetcode.com/submissions/detail/184165156/
public class CompareVersionNumbers
{
//public static void Main(string[] args)
//{
// CompareVersionNumbers comp = new CompareVersionNumbers();
// Console.WriteLine(comp.CompareVersion("1.0.1", "1")); // 1
// Console.WriteLine(comp.CompareVersion("01", "1")); // -1
// Console.ReadKey();
//}
public int CompareVersion(string version1, string version2)
{
string[] v1 = version1.Split('.');
string[] v2 = version2.Split('.');
int length = System.Math.Max(v1.Length, v2.Length);
for (int index = 0; index < length; index++)
{
int num1 = index < v1.Length ? Convert.ToInt32(v1[index]) : 0;
int num2 = index < v2.Length ? Convert.ToInt32(v2[index]) : 0;
if (num1.CompareTo(num2) != 0)
return num1.CompareTo(num2);
}
return 0;
}
public int CompareVersion1(string version1, string version2)
{
int index = 0;
int length1 = version1.Length, length2 = version2.Length;
while (true)
{
if (index < length1 && (index >= length2 || version1[index] > version2[index]))
return 1;
else if (index < length2 && (index >= length1 || version1[index] < version2[index]))
return -1;
else
return 0;
index += 2;
}
}
}
}
|
0b5511c0f8efd899f8d6fc79c9d0209c587188fb
|
C#
|
Asianatix/TheQuickerSnipper
|
/TheQuickerSnipper/Views/MainWindow.xaml.cs
| 2.6875
| 3
|
using System;
using System.IO;
using System.Threading.Tasks;
using System.Windows.Media.Imaging;
namespace Knapcode.TheQuickerSnipper.Views
{
public partial class MainWindow
{
public MainWindow()
{
InitializeComponent();
SuffixSeperator = "_";
SelectionArea.SelectionMade += (sender, args) =>
{
// skip the selection if no file is loaded
string filePath = SelectionArea.FilePath;
if (SelectionArea.FilePath == null)
{
return;
}
// skip the selection if there is no width or height
if (args.ImageSelection.Width == 0 || args.ImageSelection.Height == 0)
{
return;
}
var image = new CroppedBitmap(SelectionArea.ImageSource, args.ImageSelection);
var encoder = new JpegBitmapEncoder();
encoder.QualityLevel = 95;
encoder.Frames.Add(BitmapFrame.Create(image));
var memoryStream = new MemoryStream();
encoder.Save(memoryStream);
memoryStream.Position = 0;
Task.Factory.StartNew(() =>
{
// parse the old file name
string directory = Path.GetDirectoryName(filePath) ?? ".";
string fileName = Path.GetFileNameWithoutExtension(filePath) ?? string.Empty;
string extension = ".jpg";
// get highest number suffix
string[] otherPaths = Directory.GetFiles(directory, fileName + "*");
int maxSuffixInt = 0;
int prefixLength = fileName.Length + SuffixSeperator.Length;
foreach (string otherPath in otherPaths)
{
string otherFileName = Path.GetFileNameWithoutExtension(otherPath) ?? string.Empty;
if (otherFileName.Length < prefixLength)
{
continue;
}
string suffix = otherFileName.Substring(prefixLength);
int suffixInt;
if (int.TryParse(suffix, out suffixInt))
{
}
maxSuffixInt = Math.Max(maxSuffixInt, suffixInt);
}
// generate the new file name
string newFilePath = Path.Combine(directory, fileName + SuffixSeperator + (maxSuffixInt + 1) + extension);
// write the file
using (var stream = new FileStream(newFilePath, FileMode.Create))
{
memoryStream.CopyTo(stream);
}
memoryStream.Dispose();
});
};
}
public string SuffixSeperator { get; set; }
}
}
|
97298851b59a63f8fb22cf3074e7c4ce6964a089
|
C#
|
sebas77/Svelto.Tasks.Examples
|
/Assets/Svelto.Tasks/Svelto.Tasks/TaskContract.cs
| 2.640625
| 3
|
using System.Collections;
using System.Runtime.InteropServices;
using Svelto.Tasks.Enumerators;
namespace Svelto.Tasks
{
public struct TaskContract
{
TaskContract(int number) : this()
{
_currentState = states.value;
_returnValue.int32 = number;
}
TaskContract(ContinuationEnumerator continuation) : this()
{
_currentState = states.continuation;
_returnObjects.continuation = continuation;
}
public TaskContract(IEnumerator enumerator) : this()
{
_currentState = states.enumerator;
_returnObjects.reference = enumerator;
}
public TaskContract(Break breakit) : this()
{
_currentState = states.breakit;
_returnObjects.breakIt = breakit;
}
public TaskContract(Yield yieldIt) : this()
{
_currentState = states.yieldit;
}
public TaskContract(float val) : this()
{
_currentState = states.value;
_returnValue.single = val;
}
public TaskContract(object val) : this()
{
_currentState = states.value;
_returnObjects.reference = val;
}
public TaskContract(string val) : this()
{
_currentState = states.value;
_returnObjects.reference = val;
}
[StructLayout(LayoutKind.Explicit)]
struct fieldValues
{
[FieldOffset(0)] internal float single;
[FieldOffset(0)] internal int int32;
}
[StructLayout(LayoutKind.Explicit)]
struct fieldObjects
{
[FieldOffset(0)] internal object reference;
[FieldOffset(0)] internal Break breakIt;
[FieldOffset(0)] internal ContinuationEnumerator continuation;
}
public static implicit operator TaskContract(int number)
{
return new TaskContract(number);
}
public static implicit operator TaskContract(float number)
{
return new TaskContract(number);
}
public static implicit operator TaskContract(long number)
{
return new TaskContract(number);
}
public static implicit operator TaskContract(ContinuationEnumerator continuation)
{
return new TaskContract(continuation);
}
public static implicit operator TaskContract(Break breakit)
{
return new TaskContract(breakit);
}
public static implicit operator TaskContract(Yield yieldit)
{
return new TaskContract(yieldit);
}
public int ToInt()
{
return _returnValue.int32;
}
public float ToFloat()
{
return _returnValue.single;
}
public Break breakit
{
get { return _currentState == states.breakit ?_returnObjects.breakIt : null; }
}
public IEnumerator enumerator
{
get { return _currentState == states.enumerator ? (IEnumerator) _returnObjects.reference : null; }
}
public ContinuationEnumerator ContinuationEnumerator
{
get { return _currentState == states.continuation ? _returnObjects.continuation : null; }
}
public object reference
{
get { return _currentState == states.value ? _returnObjects.reference : null; }
}
public bool hasValue
{
get { return _currentState == states.value; }
}
public bool yieldIt
{
get { return _currentState == states.yieldit; }
}
fieldValues _returnValue;
readonly fieldObjects _returnObjects;
readonly states _currentState;
enum states
{
yieldit = 0,
value,
continuation,
breakit,
enumerator
}
}
}
|
18c8299c20f975adcabf1b0ecd3477bf09faf94d
|
C#
|
shendongnian/download4
|
/code9/1593044-44513323-149225934-4.cs
| 2.65625
| 3
|
dynamic testObject = new LoggedPropertyAccess();
string firstname = testObject.FirstName;
string lastname = testObject.LastName;
foreach (var propertyName in testObject.accessedPropertyNames) {
Console.WriteLine(propertyName);
}
Console.ReadKey();
|
51d632d81d7e4cf0dfdc8ab063bb52e38714a30d
|
C#
|
pnjeffries/Nucleus
|
/Nucleus/Nucleus.Game/Components/Abilities/OpenDoorAbility.cs
| 2.703125
| 3
|
using Nucleus.Game.Actions;
using Nucleus.Geometry;
using Nucleus.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Nucleus.Game.Components.Abilities
{
/// <summary>
/// Data component which confers the ability to open doors
/// </summary>
[Serializable]
public class OpenDoorAbility : Ability
{
public override void GenerateActions(TurnContext context, AvailableActions addTo)
{
MapData mD = context.Element?.GetData<MapData>();
if (mD != null && mD.MapCell != null)
{
var adjacent = context.Stage?.Map?.AdjacentCells(mD.MapCell.Index);
foreach (var cell in adjacent)
{
Vector direction = cell.Position - mD.MapCell.Position;
Element target = context.Element.GetData<MapCellCollider>()?.Blocker(cell); //cell.Contents.FirstWithDataComponent<Door>();
if (target != null && target.HasData<Door>())
{
addTo.Actions.Add(new OpenDoorAction(target));
}
}
}
}
}
}
|
ad7e930fe387f960a4f7152b1e9169d2ccc23031
|
C#
|
bodommer/Monopoly
|
/Monopoly/Players/Player.cs
| 2.796875
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Monopoly.Main;
using System.Drawing;
namespace Monopoly.Players
{
/**
* A base container for both HumanPlayer and AIPlayer. Contains basic attributes the two types
* of players have in common.
*/
[Serializable()]
public abstract class Player
{
public int Blocked { get; set; }
public float Money { get; set; }
public bool Prison = false;
public string name;
public Color Color { get; set; } = Color.Goldenrod;
public override string ToString()
{
return name;
}
}
}
|
92b591d1a9a16c139bf02b90b1322f980260f5b2
|
C#
|
thanlong2910/XoamuLaptrinh01
|
/ConsoleApp1/Bai28/Program.cs
| 3.5625
| 4
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Bai28
{
// Viết chương trình nhập n là số thập phân(n <= 255), n sang số nhị phân có 8 chữ số.
// Ví dụ:
// 1 = 00000001
// 10 = 00001010
// 255 = 11111111
class Program
{
static void Main(string[] args)
{
// Hiển thị tiếng Việt trên console
Console.OutputEncoding = System.Text.Encoding.UTF8;
// In đề bài
Console.WriteLine("Viết chương trình nhập n là số thập phân(n <= 255), n sang số nhị phân có 8 chữ số");
Console.WriteLine(" Ví dụ: // 1 = 00000001 // 10 = 00001010 // 255 = 11111111");
Console.WriteLine("***********************************************************************");
Console.WriteLine("");
// Nhập số nguyên - n
int inputNumber;
Console.WriteLine("Nhập số nguyên n: ");
inputNumber = SetIntegerNumber();
// In ra số nhị phân
ConvertToBinaryNumber(inputNumber);
Console.ReadLine();
}
// Hàm nhập số nguyên
static int SetIntegerNumber()
{
int number;
number = int.Parse(Console.ReadLine());
return number;
}
// Hàm đổi thập phân sang nhị phân
static void ConvertToBinaryNumber(int tempIntegerNumber)
{
string str = "";
while ((tempIntegerNumber / 2) != 0)
{
str = str + (tempIntegerNumber % 2);
tempIntegerNumber = tempIntegerNumber / 2;
}
// Cộng thêm chữ số cuối cùng của phép chia 2
str = str + tempIntegerNumber;
// Bổ sung thêm số 0 cho đủ nhị phân 8 bits
int n = 8 - str.Length;
for (int i = 0; i < n; i++)
{
str = str + "0";
}
// Đảo chuỗi str
str = ReverseString(str);
Console.WriteLine(str);
}
// Hàm đảo chuỗi
static string ReverseString(string str)
{
char[] charArray = str.ToCharArray();
Array.Reverse(charArray);
return new string(charArray);
}
}
}
|
d5e053e6980e4c80f5bb3837aa5a2e0fc7379235
|
C#
|
Luizhbc/JurosCompostoSimples
|
/Program.cs
| 3.484375
| 3
|
using System;
namespace Juros_Compostos
{
class Program
{
static void Main(string[] args)
{
string i = "S";
while(i == "S")
{
Console.Clear();
JurosCalcMethod();
Console.WriteLine("Deseja continuar? [S/N]: ");
i = Console.ReadLine();
i = i.ToUpper();
}
}
static void JurosCalcMethod()
{
Console.WriteLine("----------------------------------------");
Console.WriteLine("|------Calculadora Juros compostos-----|");
Console.WriteLine("----------------------------------------");
Console.WriteLine("Valor inicial:");
double initialValue = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Total de Juros a.a:");
double interestAA = Convert.ToDouble(Console.ReadLine());
interestAA = (interestAA / 100)/12 ;
Console.WriteLine("Tempo para pagar em meses: ");
int payTime = Convert.ToInt32(Console.ReadLine());
InterestTotal(initialValue, interestAA, payTime);
static void InterestTotal(double init, double aaTotal, int timeToPay)
{
aaTotal = aaTotal + 1;
double totalToPay = init * (Math.Pow(aaTotal, timeToPay));
double totJuros = totalToPay - init;
//Console.WriteLine("Total a pagar: " + totalToPay + " Juros total: " + (totalToPay-aaTotal));
Console.WriteLine("Valor total: " + totalToPay.ToString("C"));
Console.WriteLine("Valor Juros: " + totJuros.ToString("C"));
}
}
}
}
|
8124fbe77cb43630b3ac2e4fafa9c3306626981d
|
C#
|
Nekroido/modpackupdater
|
/Updater/Classes/Api.cs
| 2.84375
| 3
|
using Newtonsoft.Json;
using System;
using System.Net.Http;
using System.Threading.Tasks;
using Updater.Models;
namespace Updater.Classes
{
public class Api
{
public static async Task<VersionModel> GetModpackVersion()
{
return await Request<VersionModel>(Config.MODPACK_URL + Config.MODPACK_INFO);
}
private static async Task<T> Request<T>(string url)
{
var response = await GetRequest(url);
if (response != null)
{
var result = JsonConvert.DeserializeObject<T>(response);
if (result != null)
{
return result;
}
}
return default(T);
}
private static async Task<string> GetRequest(string url)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine(url);
#endif
try
{
using (var c = new HttpClient())
{
//c.Timeout = new TimeSpan(5000);
var response = await c.GetStringAsync(url);
return response;
}
}
catch (Exception e)
{
// Log and continue
#if DEBUG
System.Diagnostics.Debug.WriteLine(e.ToString());
#endif
}
return null;
}
}
}
|
bae9bcd6324cf86fcbf199db14edb0c2078af1c2
|
C#
|
ffhighwind/DapperExtraCRUD
|
/DapperExtraCRUD.Cache.Example/Program.cs
| 2.84375
| 3
|
using System;
using System.Data.SqlClient;
using Dapper.Extra.Annotations;
using Dapper.Extra.Cache;
using Dapper;
namespace Example
{
[Table("Employees")]
public class Employee
{
[Key]
public int EmployeeID { get; set; }
public string UserName { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public DateTime HireDate { get; set; }
public int ManagerID { get; set; }
public DateTime DateOfBirth { get; set; }
[IgnoreInsert("getdate()")]
[MatchUpdate("getdate()")]
[AutoSync(syncInsert: true, syncUpdate: true)]
public DateTime ModifiedDate { get; set; }
[IgnoreInsert("getdate()", true)]
[IgnoreUpdate]
public DateTime CreatedDate { get; set; }
}
public class EmployeeItem : CacheItem<Employee>
{
public int ID => CacheValue.EmployeeID;
public string UserName => CacheValue.UserName;
public string Name => CacheValue.FirstName + " " + CacheValue.LastName;
public DateTime HireDate => CacheValue.HireDate;
public EmployeeItem Manager => LazyManager.Value;
public DateTime DOB => CacheValue.DateOfBirth;
public double Age => (DateTime.Today - CacheValue.DateOfBirth).TotalDays / 365.0;
public DateTime ModifiedDate => CacheValue.ModifiedDate;
public DateTime CreatedDate => CacheValue.CreatedDate;
private Lazy<EmployeeItem> LazyManager;
protected override void OnValueChanged()
{
// Lazy is required here or this could be costly
LazyManager = new Lazy<EmployeeItem>(() => DB.Employees[CacheValue.ManagerID], false);
}
public bool Save()
{
// returns false if deleted or the row was not modified
return DB.Employees.Update(CacheValue);
}
public bool Load()
{
EmployeeItem value = DB.Employees.Get(CacheValue);
return value == this;
}
}
public static class DB
{
private const string ConnString = "Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;";
private static readonly DbCache Cache = new DbCache(ConnString);
public static readonly DbCacheTable<Employee, EmployeeItem> Employees = Cache.CreateTable<Employee, EmployeeItem>();
public static DateTime GetDate()
{
using (SqlConnection conn = new SqlConnection(ConnString)) {
// getdate() could be replaced by SqlAdapter.CurrentDateTime
return conn.QueryFirst<DateTime>("select getdate()");
}
}
}
public static class Program
{
public static void Main()
{
DB.Employees.GetList(); // caches all employees in the database
try {
using (DbCacheTransaction transaction = DB.Employees.BeginTransaction()) {
Employee emp = new Employee() {
DateOfBirth = new DateTime(2000, 2, 15),
FirstName = "Jack",
LastName = "Black",
HireDate = DB.GetDate(),
UserName = "blackj",
ManagerID = 2,
};
EmployeeItem empItem = DB.Employees.Insert(emp); // automatically uses the transaction
Console.WriteLine("Manager: " + empItem.Manager.Name + "\nAge: " + empItem.Manager.Age);
transaction.Commit();
}
}
catch (Exception ex) {
// roll back cache to before the transaction
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
// etc...
}
}
}
|
9a58cd2df4a6087ae9a6a34645880ede61925fef
|
C#
|
Danny000012/LawTrust
|
/Framework/Services/API.cs
| 2.734375
| 3
|
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Framework.Models;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using RestSharp;
namespace Framework.Services
{
public class API<T>
{
public RestClient restClient;
public RestRequest restRequest;
public string baseUrl = "https://jsonplaceholder.typicode.com/";
public RestClient SetUrl(string endpoint)
{
var url = Path.Combine(baseUrl, endpoint);
var restClient = new RestClient(url);
return restClient;
}
public RestRequest CreatePostRequest(string newUser)
{
var restRequest = new RestRequest(Method.POST);
restRequest.AddHeader("Accept", "application/json");
restRequest.AddParameter("application/json", newUser, ParameterType.RequestBody);
return restRequest;
}
public RestRequest CreateGetRequest()
{
var restRequest = new RestRequest(Method.GET);
restRequest.AddHeader("Accept", "application/json");
return restRequest;
}
public IRestResponse GetResponse(RestClient client, RestRequest request)
{
return client.Execute(request);
}
public List<Root> GetContent(string response)
{
var myDeserializedClass = JsonConvert.DeserializeObject<List<Root>>(response);
return myDeserializedClass;
}
}
}
|
adcb459215bc0f200b2501d161750e42be414193
|
C#
|
tmsang12a14tkn/VITV
|
/VITV.Data/Repositories/SettingRepository.cs
| 2.875
| 3
|
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Linq.Expressions;
using System.Web;
using VITV.Data.DAL;
using VITV.Data.Models;
namespace VITV.Data.Repositories
{
public class SettingRepository : ISettingRepository
{
private readonly VITVContext _context;
public SettingRepository(VITVContext context)
{
_context = context;
}
public SettingRepository()
{
_context = new VITVContext();
}
public IQueryable<Setting> All
{
get { return _context.Settings; }
}
public IQueryable<Setting> AllIncluding(params Expression<Func<Setting, object>>[] includeProperties)
{
return includeProperties.Aggregate<Expression<Func<Setting, object>>, IQueryable<Setting>>(_context.Settings, (current, includeProperty) => current.Include(includeProperty));
}
public Setting Find(string name)
{
var setting = _context.Settings.Find(name);
if (setting == null)
{
setting = new Setting
{
Name = name,
Value = ""
};
Save();
}
return setting;
}
public string GetValue(string name)
{
var setting = Find(name);
return setting.Value;
}
public void Load<TElement>(Setting Setting, Expression<Func<Setting, ICollection<TElement>>> includeProperty) where TElement : class
{
_context.Settings.Attach(Setting);
_context.Entry(Setting).Collection(includeProperty).Load();
}
public IEnumerable<Setting> GetMany(Expression<Func<Setting, bool>> where)
{
return _context.Settings.Where(where).ToList();
}
public void InsertOrUpdate(Setting setting)
{
if (_context.Settings.AsNoTracking().All(s=>s.Name != setting.Name))
{
// New entity
_context.Settings.Add(setting);
} else {
// Existing entity
_context.Entry(setting).State = EntityState.Modified;
}
}
public void Delete(string name)
{
var Setting = _context.Settings.Find(name);
_context.Settings.Remove(Setting);
}
public void Save()
{
_context.SaveChanges();
}
public void Dispose()
{
_context.Dispose();
}
}
public interface ISettingRepository : IDisposable
{
IQueryable<Setting> All { get; }
IQueryable<Setting> AllIncluding(params Expression<Func<Setting, object>>[] includeProperties);
Setting Find(string name);
string GetValue(string name);
IEnumerable<Setting> GetMany(Expression<Func<Setting, bool>> where);
void Load<TElement>(Setting Setting, Expression<Func<Setting, ICollection<TElement>>> includeProperty) where TElement : class;
void InsertOrUpdate(Setting Setting);
void Delete(string name);
void Save();
}
}
|
abc4be653c1f96dbc746b77324c2d462d7c22631
|
C#
|
Centronics/DynamicMosaicExample
|
/DynamicMosaicExample/ConcurrentProcessorStorage.cs
| 2.90625
| 3
|
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Threading;
using DynamicMosaic;
using DynamicParser;
namespace DynamicMosaicExample
{
/// <summary>
/// Потокобезопасное хранилище карт <see cref="Processor" />.
/// </summary>
/// <remarks>
/// Абстрактный класс. Обеспечивает базовую функциональность, без учёта особенностей хранимых карт.
/// Позволяет идентифицировать карты как по путям хранения, так и по индексу.
/// Предоставляет следующие функции для управления хранилищем.
/// 1) Сохраняет карты на жёсткий диск (номерует их при совпадении названий).
/// 2) Позволяет загружать карты как массово (путь к папке с картами), так и по одиночке.
/// 3) Позволяет перечислять карты с уникальными именами или "как есть".
/// </remarks>
public abstract class ConcurrentProcessorStorage
{
/// <summary>
/// Тип используемого хранилища.
/// </summary>
public enum ProcessorStorageType
{
/// <summary>
/// Хранилище карт, которые требуется найти.
/// </summary>
IMAGE,
/// <summary>
/// Хранилище карт, которые требуется исследовать последством карт <see cref="IMAGE" />.
/// </summary>
RECOGNIZE
}
/// <summary>
/// Хранит значение свойства <see cref="LongOperationsAllowed"/>.
/// Значение по умолчанию - <see langword="true" />.
/// </summary>
static bool _longOperationsAllowed = true;
/// <summary>
/// Синхронизирует доступ к значению <see cref="_longOperationsAllowed"/> при изменении статического свойства <see cref="LongOperationsAllowed"/>.
/// </summary>
static readonly object LongOperationsSync = new object();
/// <summary>
/// Коллекция карт, идентифицируемых по хешу.
/// </summary>
protected readonly Dictionary<int, ProcHash> DictionaryByHash = new Dictionary<int, ProcHash>();
/// <summary>
/// Коллекция карт, идентифицируемых по ключам. Ключ представляет собой путь в LowerCase формате.
/// </summary>
protected readonly Dictionary<string, ProcPath> DictionaryByKey = new Dictionary<string, ProcPath>();
/// <summary>
/// Объект для синхронизации доступа к экземпляру класса <see cref="ConcurrentProcessorStorage" />, с использованием
/// инструкции <see langword="lock" />.
/// </summary>
/// <remarks>
/// С целью исключения возможных взаимоблокировок при обращении к нему нескольких потоков, доступ к объекту <see cref="ConcurrentProcessorStorage" /> синхронизируется только с помощью этого объекта.
/// </remarks>
protected readonly object SyncObject = new object();
/// <summary>
/// Хранит значение свойства <see cref="SelectedPath"/>.
/// Значение по умолчанию - <see cref="string.Empty"/>.
/// </summary>
string _selectedPath = string.Empty;
/// <summary>
/// Хранит значение для свойства <see cref="SelectedIndex"/>.
/// Значение по умолчанию -1.
/// </summary>
protected int IntSelectedIndex = -1;
/// <summary>
/// Внутренний конструтор, используется для передачи значений внутренним переменным.
/// </summary>
/// <param name="extImg">Расширение файлов с изображениями. Любой регистр, без точки.</param>
protected ConcurrentProcessorStorage(string extImg)
{
ExtImg = extImg;
}
/// <summary>
/// Получает расширение файлов с изображениями, с которым работает текущий экземпляр.
/// </summary>
public string ExtImg { get; }
/// <summary>
/// Рабочий каталог. Зависит от типа хранилища. Реализации по умолчанию нет.
/// </summary>
/// <remarks>
/// Используется для определения того, является ли указанный каталог рабочим или нет.
/// При выполнении различных операций с картами, в зависимости от этого параметра, принимаются те или иные решения.
/// Например, определение типа хранилища, исходя из сведений о пути к его рабочему каталогу.
/// Этот каталог существует всегда. Если его не существует, он должен быть создан с помощью метода <see cref="CreateWorkingDirectory()" /> или создастся автоматически, при вызове соответствующего метода.
/// В него всегда сохраняются карты, которые требуется сохранить.
/// </remarks>
/// <seealso cref="CreateWorkingDirectory()"/>
public abstract string WorkingDirectory { get; }
/// <summary>
/// Текущий тип хранилища.
/// </summary>
public abstract ProcessorStorageType StorageType { get; }
/// <summary>
/// Получает все элементы, добавленные в коллекцию <see cref="ConcurrentProcessorStorage" />.
/// </summary>
public IEnumerable<Processor> Elements
{
get
{
lock (SyncObject)
{
return DictionaryByKey.Values.Select(p => p.CurrentProcessor);
}
}
}
/// <summary>
/// Получает количество карт, содержащихся в коллекции <see cref="ConcurrentProcessorStorage" />.
/// </summary>
/// <remarks>
/// Если требуется узнать, является ли коллекция пустой или нет, можно воспользоваться свойством <see cref="IsEmpty"/>.
/// </remarks>
/// <seealso cref="IsEmpty"/>
public int Count
{
get
{
lock (SyncObject)
{
return DictionaryByKey.Count;
}
}
}
/// <summary>
/// Определяет, содержит ли коллекция <see cref="ConcurrentProcessorStorage" /> какие-либо элементы.
/// </summary>
/// <seealso cref="Count"/>
public bool IsEmpty
{
get
{
lock (SyncObject)
{
return !DictionaryByKey.Any();
}
}
}
/// <summary>
/// Получает карту по указанному индексу.
/// </summary>
/// <param name="index">Индекс карты, которую требуется получить.</param>
/// <returns>Возвращает карту <see cref="Processor" /> по указанному индексу, путь к ней, и количество карт в коллекции.</returns>
/// <remarks>
/// Если индекс представляет собой недопустимое значение, будут возвращены следующие значения: (<see langword="null" />, <see cref="string.Empty" />, <see cref="Count" />).
/// </remarks>
(Processor processor, string path, int count) this[int index]
{
get
{
lock (SyncObject)
{
int count = Count;
if (index < 0 || index >= count)
return (null, string.Empty, count);
ProcPath pp = DictionaryByKey.Values.ElementAt(index);
return (pp.CurrentProcessor, pp.CurrentPath, count);
}
}
}
/// <summary>
/// Возвращает карту <see cref="Processor" /> по указанному пути, путь к ней, и количество карт в коллекции.
/// От наличия файла на жёстком диске не зависит.
/// Если карта отсутствует, возвращается (<see langword="null" />, <see cref="string.Empty" />, <see cref="Count" />).
/// </summary>
/// <param name="fullPath">Полный путь к карте <see cref="Processor" />.</param>
/// <returns>Возвращает карту <see cref="Processor" /> по указанному пути, путь к ней, и количество карт в коллекции.</returns>
public (Processor processor, string path, int count) this[string fullPath]
{
get
{
if (string.IsNullOrWhiteSpace(fullPath))
return (null, string.Empty, Count);
lock (SyncObject)
{
return DictionaryByKey.TryGetValue(GetStringKey(fullPath), out ProcPath p) ?
(p.CurrentProcessor, p.CurrentPath, Count) :
(null, string.Empty, Count);
}
}
}
/// <summary>
/// Получает путь к последней карте, к которой было обращение с помощью различных методов (добавление, сохранение, выборка по индексу (<see cref="GetFirstProcessor"/> или <see cref="GetLatestProcessor"/>).
/// С помощью свойства <see cref="SelectedIndex"/> можно получить её индекс в коллекции.
/// </summary>
/// <remarks>
/// Является потокобезопасным.
/// Значение этого свойства остаётся неизменным до тех пор, пока не будет изменено или сброшено либо добавлением (сохранением) карты, либо удалением текущей карты, в том числе, очисткой всей коллекции или обращением по индексу (<see cref="GetFirstProcessor"/> или <see cref="GetLatestProcessor"/>).
/// Если требуется узнать, выбрана ли какая-либо карта на данный момент, можно воспользоваться свойством <see cref="IsSelectedOne"/>.
/// Доступ на запись возможен только изнутри этого класса, и служит для актуализации значения этого свойства с последующим сбросом значения свойства <see cref="SelectedIndex"/>.
/// Чтение и запись производятся с блокировками. Если свойство сброшено, его значением будет <see cref="string.Empty" />.
/// </remarks>
/// <seealso cref="SelectedIndex"/>
/// <seealso cref="IsSelectedOne"/>
public string SelectedPath
{
get
{
lock (SyncObject)
{
return _selectedPath;
}
}
protected set
{
lock (SyncObject)
{
_selectedPath = value ?? string.Empty;
SelectedIndex = -1;
}
}
}
/// <summary>
/// Получает статус текущей выбранной карты на данный момент.
/// </summary>
/// <remarks>
/// Является потокобезопасным.
/// Значение свойства может быть сброшено либо удалением текущей карты, в том числе, очисткой всей коллекции.
/// В случае, когда это свойство содержит значение <see langword="true" />, свойство <see cref="SelectedPath"/> содержит путь к этой карте.
/// </remarks>
/// <seealso cref="SelectedPath"/>
/// <seealso cref="SelectedIndex"/>
public virtual bool IsSelectedOne => !string.IsNullOrEmpty(SelectedPath);
/// <summary>
/// Получает индекс последней карты, к которой было обращение с помощью различных методов (добавление, сохранение, выборка по индексу (<see cref="GetFirstProcessor"/> или <see cref="GetLatestProcessor"/>).
/// </summary>
/// <remarks>
/// Является потокобезопасным.
/// Значение получается путём линейного поиска индекса карты, находящейся по пути <see cref="SelectedPath"/>.
/// После чтения значения оно сохраняется во внутренней переменной <see cref="IntSelectedIndex"/>, далее читается оттуда до тех пор, пока не будет сброшено (примет значение -1) либо добавлением (сохранением) карты,
/// либо удалением текущей карты, в том числе, очисткой всей коллекции или обращением по индексу (<see cref="GetFirstProcessor"/> или <see cref="GetLatestProcessor"/>).
/// Доступ на запись возможен только изнутри этого класса, и служит для сброса значения этого свойства.
/// </remarks>
/// <seealso cref="SelectedPath"/>
/// <seealso cref="IsSelectedOne"/>
public int SelectedIndex
{
get
{
lock (SyncObject)
{
if (IntSelectedIndex > -1)
return IntSelectedIndex;
string selectedPath = SelectedPath;
if (string.IsNullOrEmpty(selectedPath))
return -1;
string findKey = GetStringKey(selectedPath);
int index = DictionaryByKey.Keys.TakeWhile(key => key != findKey).Count();
IntSelectedIndex = index < DictionaryByKey.Count ? index : -1;
return IntSelectedIndex;
}
}
private set
{
lock (SyncObject)
{
IntSelectedIndex = value;
}
}
}
/// <summary>
/// Статическое свойство.
/// Получает или задаёт значение, указывающее, разрешены или запрещены длительные операции.
/// </summary>
/// <remarks>
/// Например, операции перечисления файлов, связанные с выполнением каких-либо действий, например, массовым добавлением или удалением карт из коллекции.
/// Если во время выполнения длительной операции значение свойства будет изменено на <see langword="false" />, операция(-ции) будет прервана.
/// Это свойство является потокобезопасным.
/// Запись производится с помощью блокировки, чтение без блокировки.
/// Как правило, применяется перед завершением работы приложения.
/// Значение по умолчанию - <see langword="true" />.
/// </remarks>
public static bool LongOperationsAllowed
{
get => _longOperationsAllowed;
set
{
lock (LongOperationsSync)
{
_longOperationsAllowed = value;
}
}
}
/// <summary>
/// Получает те же элементы, что и <see cref="Elements" />, отличающиеся уникальными именами.
/// </summary>
/// <remarks>
/// Имена будут уникальными даже в случае, когда элементы находятся в разных папках.
/// Отличаются только значения свойств <see cref="Processor.Tag" />.
/// </remarks>
/// <seealso cref="Elements"/>
/// <seealso cref="Processor.Tag"/>
public IEnumerable<Processor> UniqueElements
{
get
{
lock (SyncObject)
{
HashSet<string> tagSet = new HashSet<string>();
foreach ((string name, Processor p) in DictionaryByKey.Values.Select(pp =>
(Path.GetFileNameWithoutExtension(pp.CurrentPath).ToLower(), pp.CurrentProcessor)))
yield return IntGetUniqueProcessor(tagSet, p, ParseName(name), string.Empty).processor;
}
}
}
/// <summary>
/// Получает уникальные имена хранимых в коллекции карт, что и <see cref="UniqueElements"/>, только в виде набора строк.
/// </summary>
/// <remarks>
/// Следует использовать для оптимизации производительности, т.к. в этом случае нет накладных расходов на создание копии набора карт, как в случае со свойством <see cref="UniqueElements"/>.
/// </remarks>
/// <seealso cref="UniqueElements"/>
protected HashSet<string> UniqueNames
{
get
{
HashSet<string> tagSet = new HashSet<string>();
foreach (string name in DictionaryByKey.Values.Select(pp =>
Path.GetFileNameWithoutExtension(pp.CurrentPath).ToLower()))
IntGetUniqueProcessor(tagSet, null, ParseName(name), string.Empty);
return tagSet;
}
}
/// <summary>
/// Считывает карту по указанному пути (не добавляя её в коллекцию), выполняя все необходимые проверки, характерные для текущего типа хранилища.
/// </summary>
/// <param name="fullPath">Путь к файлу, который содержит карту.</param>
/// <returns>Возвращает считанную карту.</returns>
/// <remarks>
/// Реализация по умолчанию отсутствует.
/// Для определения типа хранилища см. <see cref="StorageType"/>.
/// Метод потокобезопасен.
/// </remarks>
/// <seealso cref="StorageType"/>
protected abstract Processor GetAddingProcessor(string fullPath);
/// <summary>
/// Получает полный путь (с расширением) к указанному имени карты.
/// </summary>
/// <param name="sourcePath">Путь к рабочей папке. Как правило, <see cref="WorkingDirectory"/>.</param>
/// <param name="fileName">Имя файла, содержащего карту.</param>
/// <returns>Полный путь к карте.</returns>
/// <remarks>
/// Метод потокобезопасен.
/// Расширение содержится в свойстве <see cref="ExtImg"/>.
/// </remarks>
protected string CreateImagePath(string sourcePath, string fileName)
{
return
$@"{Path.Combine(sourcePath ?? throw new ArgumentException($@"{nameof(CreateImagePath)}: Исходный путь карты не указан."), fileName)}.{ExtImg}";
}
/// <summary>
/// Выполняет разбор (демаскировку) названия карты, разделяя его с помощью символа <see cref="ImageRect.TagSeparatorChar"/>.
/// </summary>
/// <param name="name">Название, которое требуется разобрать. Не может быть пустым.</param>
/// <returns>Возвращает номер (или <see langword="null" />, если его нет) и имя карты, без маскировки.</returns>
/// <remarks>
/// Метод потокобезопасен.
/// Номер карты интерпретируется как <see cref="ulong"/>.
/// </remarks>
protected static (ulong? number, string name) ParseName(string name)
{
if (string.IsNullOrEmpty(name))
throw new ArgumentNullException(nameof(name), nameof(ParseName));
for (int k = name.Length - 1; k > 0; k--)
if (name[k] == ImageRect.TagSeparatorChar)
return ulong.TryParse(name.Substring(k + 1), out ulong number)
? (number, name.Substring(0, k))
: ((ulong?)null, name);
return (null, name);
}
/// <summary>
/// Получает карту с уникальным именем, добавляя его в указанный <see cref="ISet<T>"/>.
/// </summary>
/// <param name="maskedTagSet">Набор для поддержания уникальности имён карт.</param>
/// <param name="tagProc">Карта, для которой требуется получить уникальное имя. Может быть равна <see langword="null"/>. Изначальное значение свойства <see cref="Processor.Tag"/> не имеет значения.</param>
/// <param name="hint">Подсказка по имени (обязательно) и номеру карты, в целях оптимизации производительности.</param>
/// <param name="pathToSave">Путь, по которому будет располагаться указанная карта. Может быть <see cref="string.Empty"/>, но не может быть <see langword="null"/>. Если <see cref="string.Empty"/>, то вернётся имя карты и расширение (без полного пути).</param>
/// <returns>Возвращает карту, соответствующую заданным параметрам или <see langword="null"/>. Второй параметр - путь, по которому располагается карта.</returns>
/// <remarks>
/// Карта может быть равна <see langword="null"/>. В этом случае уникальное имя будет получено и добавлено в указанный <see cref="ISet<T>"/>, но карта на выходе будет равна <see langword="null"/>.
/// Таким образом, можно получить набор уникальных имён карт без наличия их самих.
/// </remarks>
(Processor processor, string path) IntGetUniqueProcessor(ISet<string> maskedTagSet, Processor tagProc,
(ulong? number, string name) hint, string pathToSave)
{
(Processor, string) GetResult(string fileName)
{
return (tagProc != null ? ProcessorHandler.ChangeProcessorTag(tagProc, fileName) : null,
CreateImagePath(pathToSave, fileName));
}
unchecked
{
string nm = hint.name.ToLower();
if (hint.number == null && maskedTagSet.Add(nm))
return GetResult(hint.name);
ulong k = hint.number ?? 0, mk = k;
do
{
string att = $@"{nm}{ImageRect.TagSeparatorChar}{k}";
if (maskedTagSet.Add(att))
return GetResult($@"{hint.name}{ImageRect.TagSeparatorChar}{k}");
} while (++k != mk);
string pTag = tagProc != null ? tagProc.Tag : "<пусто>";
throw new Exception(
$@"Нет свободного места для добавления карты в коллекцию: {pTag} по пути {WorkingDirectory}, изначальное имя карты {hint.name}{ImageRect.TagSeparatorChar}{hint.number}.");
}
}
/// <summary>
/// Получает карту и путь к ней, задавая ей уникальное имя.
/// </summary>
/// <param name="args">Входные параметры. Значения следующие: 1) Карта, которую необходимо переименовать. Может быть <see langword="null"/>. 2) Подсказка по имени (обязательно) и номеру карты, в целях оптимизации производительности. 3) Путь, по которому будет располагаться указанная карта. Может быть пустым (<see langword="null"/> или <see cref="string.Empty"/>).</param>
/// <returns>Возвращает последовательность карт и путей к ним. Если карта не указана, то она всегда будет равна <see langword="null"/>. Если путь пустой (<see langword="null"/> или <see cref="string.Empty"/>), то будет возвращаться путь в рабочем каталоге <see cref="WorkingDirectory"/>.</returns>
/// <remarks>
/// Принимает массив различных параметров для преобразования.
/// Это сделано для того, чтобы инициализировать внутренний набор один раз для обработки всех входных данных, с целью оптимизации производительности.
/// Если указанный путь окажется полным, метод вернёт карту и путь без изменений.
/// </remarks>
protected IEnumerable<(Processor processor, string path)> GetUniqueProcessor(
IEnumerable<(Processor, (ulong?, string), string)> args)
{
HashSet<string> tagSet = null;
foreach ((Processor p, (ulong?, string) t, string pathToSave) in args)
{
string argPath = pathToSave;
if (CheckImagePath(ref argPath))
{
yield return (p, argPath);
continue;
}
if (tagSet == null)
tagSet = UniqueNames;
yield return IntGetUniqueProcessor(tagSet, p, t, argPath);
}
}
/// <summary>
/// Получает уникальный путь для сохраняемой карты.
/// </summary>
/// <param name="tag">Название карты.</param>
/// <returns>Возвращает путь в рабочем каталоге <see cref="WorkingDirectory"/>.</returns>
/// <remarks>
/// В случае необходимости, название карты маскируется.
/// Возвращает только полный путь.
/// </remarks>
/// <seealso cref="ExtImg"/>
protected string GetUniquePath(string tag)
{
return GetUniqueProcessor(new[]
{ ((Processor)null, (ParseName(tag).number == null ? (ulong?)null : 0, tag), string.Empty) }).Single().path;
}
/// <summary>
/// Присоединяет указанную часть пути (папку) к <see cref="WorkingDirectory"/>.
/// </summary>
/// <param name="folderName">Имя папки внутри рабочего каталога <see cref="WorkingDirectory"/>.</param>
/// <returns>
/// Возвращает полный путь к указанной папке.
/// </returns>
/// <remarks>
/// Метод потокобезопасен.
/// В случае нахождения некорректных символов, они будут заменены на символ подчёркивания.
/// Путь корректируется с помощью метода <see cref="ReplaceInvalidPathChars"/>.
/// Если путь пустой (<see langword="null"/> или <see cref="string.Empty"/>), то будет возвращаться путь в рабочем каталоге <see cref="WorkingDirectory"/>.
/// Если имя папки будет содержать корневой каталог, будет возвращён именно этот путь.
/// </remarks>
public string CombinePaths(string folderName)
{
return Path.Combine(WorkingDirectory, ReplaceInvalidPathChars(folderName));
}
/// <summary>
/// Заменяет недопустимые символы, которые не должен содержать путь, на подчёркивания.
/// </summary>
/// <param name="path">Исследуемый путь.</param>
/// <returns>
/// Возвращает исправленный путь, если в нём были найдены какие-либо недопустимые символы.
/// В противном случае, возвращает исходный путь.
/// </returns>
/// <remarks>
/// Метод потокобезопасен.
/// Символы берутся из коллекции <see cref="FrmExample.InvalidCharSet"/>.
/// </remarks>
static string ReplaceInvalidPathChars(string path)
{
return string.IsNullOrEmpty(path) ? string.Empty : FrmExample.InvalidCharSet.Aggregate(path, (current, c) => current.Replace(c, '_'));
}
/// <summary>
/// Создаёт указанный каталог на жёстком диске.
/// Создаёт все подкаталоги, если они отсутствуют.
/// </summary>
/// <param name="path">Путь каталога.</param>
/// <remarks>
/// Метод потокобезопасен.
/// </remarks>
public static void CreateFolder(string path)
{
Directory.CreateDirectory(path);
}
/// <summary>
/// Создаёт рабочий каталог (<see cref="WorkingDirectory"/>) на жёстком диске.
/// </summary>
public void CreateWorkingDirectory()
{
Directory.CreateDirectory(WorkingDirectory);
}
/// <summary>
/// Определяет, находится ли указанный путь в рабочей директории (<see cref="WorkingDirectory"/>).
/// </summary>
/// <param name="path">Проверяемый путь.</param>
/// <param name="isEqual">
/// <see langword="true"/>, если требуется проверка пути полностью (пути совпадают без учёта регистра).
/// <see langword="false"/>, если требуется выяснить принадлежность (указанный путь начинается с <see cref="WorkingDirectory"/>, без учёта регистра).</param>
/// <returns>Возвращает значение <see langword="true"/> в случае, если указанный путь находится в рабочем каталоге.</returns>
/// <remarks>
/// Для метода не имеет значения наличие разделителей в конце сравниваемых путей.
/// Если они отсутствуют, метод сам их добавит для корректного сравнения.
/// Метод является потокобезопасным.
/// </remarks>
public bool IsWorkingDirectory(string path, bool isEqual = false)
{
if (string.IsNullOrEmpty(path))
throw new ArgumentException($@"{nameof(IsWorkingDirectory)}: Необходимо указать путь для проверки.",
nameof(path));
string p = AddEndingSlash(path), ip = AddEndingSlash(WorkingDirectory);
return isEqual
? string.Compare(p, ip, StringComparison.OrdinalIgnoreCase) == 0
: p.StartsWith(ip, StringComparison.OrdinalIgnoreCase);
}
/// <summary>
/// Проверяет, является ли указанный символ разделителем для строки пути.
/// </summary>
/// <param name="c">Проверяемый символ.</param>
/// <returns>Возвращает значение <see langword="true"/> в случае, если символ является таковым.</returns>
/// <remarks>
/// Проверяет как основной, так и дополнительный символ (прямой и обратный слеш).
/// Метод является потокобезопасным.
/// </remarks>
public static bool IsDirectorySeparatorSymbol(char c)
{
return c == Path.DirectorySeparatorChar || c == Path.AltDirectorySeparatorChar;
}
/// <summary>
/// Возвращает строку пути, добавив разделитель каталогов в её конец.
/// </summary>
/// <param name="path">Строка пути.</param>
/// <returns>Возвращает путь с разделителем на конце.</returns>
/// <remarks>
/// Метод потокобезопасен.
/// Для определения наличия разделителя на конце, используется метод <see cref="IsDirectorySeparatorSymbol"/>.
/// Если строка пустая (<see langword="null"/> или <see cref="string.Empty"/>), метод возвращает <see cref="string.Empty"/>.
/// </remarks>
public static string AddEndingSlash(string path)
{
if (string.IsNullOrEmpty(path))
return string.Empty;
if (!IsDirectorySeparatorSymbol(path[path.Length - 1]))
path += Path.DirectorySeparatorChar;
return path;
}
/// <summary>
/// Проверяет указанный путь на возможность его применения в текущем экземпляре <see cref="ConcurrentProcessorStorage"/> или получает путь к рабочему каталогу (<see cref="WorkingDirectory"/>) если он не указан (<see langword="null"/> или <see cref="string.Empty"/>).
/// </summary>
/// <param name="relativeFolderPath">Проверяемый путь.</param>
/// <returns>Если в параметре <paramref name="relativeFolderPath"/> отсутствуют ошибки, метод возвращает значение <see langword="true"/>.</returns>
/// <remarks>
/// В случае, когда путь <paramref name="relativeFolderPath"/> указывает на файл с картой (абсолютный путь с расширением <see cref="ExtImg"/>), метод возвращает значение <see langword="true"/>.
/// В случае, если он ведёт не в рабочий каталог, будет выброшено исключение <see cref="ArgumentException"/>.
/// В вышеуказанных случаях значение параметра <paramref name="relativeFolderPath"/> будет прежним.
/// В случае, если параметр <paramref name="relativeFolderPath"/> пустой (<see langword="null"/> или <see cref="string.Empty"/>), ему будет присвоен путь в рабочий каталог <see cref="WorkingDirectory"/>, а метод вернёт значение <see langword="false"/>.
/// Если путь <paramref name="relativeFolderPath"/> ведёт в каталог (расположенный в рабочем каталоге), то значение параметра <paramref name="relativeFolderPath"/> будет прежним, а метод вернёт значение <see langword="false"/>.
/// Для определения, указывает ли путь на каталог, служит метод <see cref="IsDirectory(string)"/>.
/// В случае, когда путь указывает на файл с другим расширением (отличным от <see cref="ExtImg"/>), будет выброшено исключение <see cref="ArgumentException"/>.
/// В этом случае значение параметра <paramref name="relativeFolderPath"/> будет прежним.
/// Метод потокобезопасен, к файловой системе не обращается.
/// </remarks>
/// <exception cref="ArgumentException"/>
public bool CheckImagePath(ref string relativeFolderPath)
{
if (string.IsNullOrEmpty(relativeFolderPath))
{
relativeFolderPath = WorkingDirectory;
return false;
}
if (!IsWorkingDirectory(relativeFolderPath))
throw new ArgumentException($@"Необходимо нахождение пути в рабочем каталоге ({WorkingDirectory})",
nameof(relativeFolderPath));
if (IsDirectory(relativeFolderPath))
return false;
if (string.Compare(Path.GetExtension(relativeFolderPath), $".{ExtImg}",
StringComparison.OrdinalIgnoreCase) != 0)
throw new ArgumentException($@"Необходимо, чтобы путь вёл к файлу с требуемым расширением ({ExtImg})",
nameof(relativeFolderPath));
return true;
}
/// <summary>
/// Получает перечисляемую коллекцию путей к изображениям, интерпретируемым как карты, в указанной папке и всех подпапках.
/// Это файлы с расширением <see cref="ExtImg" />.
/// </summary>
/// <param name="path">Путь, по которому требуется получить список файлов изображений карт.</param>
/// <returns>Возвращает запрос списка файлов.</returns>
/// <remarks>
/// Поскольку этот запрос является длительным, на него влияет флаг <see cref="LongOperationsAllowed"/>.
/// Чтобы выполнить этот запрос, необходимо вызвать соответствующий метод для того, чтобы получить коллекцию.
/// Метод является потокобезопасным.
/// </remarks>
IEnumerable<string> QueryProcessorFiles(string path)
{
return Directory.EnumerateFiles(path, $"*.{ExtImg}", SearchOption.AllDirectories)
.TakeWhile(_ => LongOperationsAllowed).Where(IsProcessorFile);
}
/// <summary>
/// Добавляет карту(ы), расположенную по указанному пути.
/// </summary>
/// <param name="fullPath">Путь к файлу или папке с картами.</param>
/// <returns>Возвращает карты, считанные по указанному пути.</returns>
/// <remarks>
/// Если в этой же папке будут находиться файлы с другими расширениями, они будут игнорироваться.
/// Чтение карт производится рекурсивно - из всех папок и подпапок.
/// В случае возникновения исключения в процессе чтения карты, если карта по указанному пути уже была добавлена в хранилище, она будет удалена из хранилища.
/// Это касается только карт, находящихся в рабочем каталоге.
/// Для добавления карт в <see cref="ConcurrentProcessorStorage"/> требуется, чтобы добавляемые карты находились в папке хранилища (<see cref="WorkingDirectory"/>), которую определяет метод <see cref="IsWorkingDirectory"/>.
/// Если карта находится за пределами рабочего каталога (<see cref="WorkingDirectory"/>), она будет считана и возвращена, но не будет добавлена в коллекцию.
/// Исключение может возникать только после завершения обработки карт. В случае получения нескольких исключений, будет выброшено <see cref="AggregateException"/>.
/// В случае деактивации флага <see cref="LongOperationsAllowed"/> метод вернёт пустой массив. <see langword="null"/> никогда не возвращается.
/// Метод потокобезопасен.
/// </remarks>
/// <exception cref="AggregateException"/>
public IEnumerable<Processor> AddProcessor(string fullPath)
{
List<Exception> lstExceptions = new List<Exception>();
bool needAdd = IsWorkingDirectory(fullPath);
IEnumerable<Processor> IntAdd()
{
if (IsProcessorFile(fullPath))
{
yield return IntAddProcessor(fullPath, needAdd);
yield break;
}
if (!IsDirectory(fullPath))
yield break;
foreach (string pFile in QueryProcessorFiles(fullPath))
{
Processor p = IntAddProcessor(pFile, needAdd, lstExceptions);
if (p != null)
yield return p;
}
}
IEnumerable<Processor> result = IntAdd().ToList();
if (!LongOperationsAllowed)
return new Processor[0];
int count = lstExceptions.Count;
if (count > 1)
throw new AggregateException(
$@"{nameof(AddProcessor)}: При загрузке группы карт возникли исключения ({count}).", lstExceptions);
if (count == 1)
throw lstExceptions[0];
return result;
}
/// <summary>
/// Добавляет карту в коллекцию, по указанному пути.
/// Если карта не подходит по каким-либо признакам, а в коллекции хранится карта по тому же пути, то она удаляется из
/// коллекции (только в случае, когда <paramref name="needAdd"/> = <see langword="true"/>).
/// Если карта уже присутствовала в коллекции, то она будет перезагружена в неё.
/// </summary>
/// <param name="fullPath">Путь к изображению, которое будет интерпретировано как карта.</param>
/// <param name="needAdd">
/// Значение <see langword="true"/> в случае необходимости добавить указанную карту в коллекцию.
/// Значение <see langword="false"/> в случае, если необходимо считать карту и вернуть её без добавления в коллекцию.
/// </param>
/// <param name="lstExceptions">Коллекция исключений, куда требуется добавить возникшее исключение. Может быть <see langword="null"/> (значение по умолчанию).</param>
/// <returns>Возвращает карту, считанную по указанному пути.</returns>
/// <remarks>
/// Если указана коллекция исключений <paramref name="lstExceptions"/>, то возникшее исключение будет добавлено в неё, и не будет выброшено, в отличии от случая, когда коллекция исключений равна <see langword="null"/> (значение по умолчанию).
/// В этом случае метод вернёт <see langword="null"/>.
/// Такой способ обработки исключений необходим для массовой загрузки карт в коллекцию.
/// В случае деактивации флага <see cref="LongOperationsAllowed"/> метод вернёт <see langword="null"/>.
/// Метод потокобезопасен.
/// </remarks>
Processor IntAddProcessor(string fullPath, bool needAdd, ICollection<Exception> lstExceptions = null)
{
try
{
Processor addingProcessor;
try
{
addingProcessor = GetAddingProcessor(fullPath);
}
catch
{
if (needAdd)
RemoveProcessor(fullPath);
if (!LongOperationsAllowed)
return null;
throw;
}
if (!LongOperationsAllowed)
return null;
if (!needAdd)
return addingProcessor;
int hashCode = GetHashCode(addingProcessor);
lock (SyncObject)
{
ReplaceElement(hashCode, fullPath, addingProcessor);
}
return LongOperationsAllowed ? addingProcessor : null;
}
catch (Exception ex)
{
if (!LongOperationsAllowed)
return null;
if (lstExceptions == null)
throw;
lstExceptions.Add(ex);
return null;
}
}
/// <summary>
/// Выполняет проверку значения <see cref="Color.A"/> цветов, применяемых в изображениях, которые будут преобразованы в карты.
/// </summary>
/// <param name="btm">Проверяемое изображение.</param>
/// <returns>Возвращает <paramref name="btm"/>.</returns>
/// <remarks>
/// Параметр <paramref name="btm"/> не может быть равен <see langword="null"/>, иначе будет выброшено исключение <see cref="ArgumentNullException"/>.
/// Для проверки используется метод <see cref="FrmExample.CheckAlphaColor(Color)"/>.
/// В случае несоответствия ожиданиям, будет выдано исключение <see cref="InvalidOperationException"/>.
/// Ожидаемое значение содержится в свойстве <see cref="FrmExample.DefaultOpacity"/>.
/// Метод потокобезопасен.
/// </remarks>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="InvalidOperationException"/>
/// <seealso cref="FrmExample.DefaultOpacity"/>
/// <seealso cref="FrmExample.CheckAlphaColor(Color)"/>
static Bitmap CheckBitmapByAlphaColor(Bitmap btm)
{
if (btm == null)
throw new ArgumentNullException(nameof(btm), $@"{nameof(CheckBitmapByAlphaColor)}: Изображение должно быть указано.");
for (int y = 0; y < btm.Height; y++)
for (int x = 0; x < btm.Width; x++)
FrmExample.CheckAlphaColor(btm.GetPixel(x, y));
return btm;
}
/// <summary>
/// Считывает изображение по указанному пути.
/// </summary>
/// <param name="fullPath">Путь к изображению.</param>
/// <returns>Возвращает считанное изображение.</returns>
/// <remarks>
/// Метод потокобезопасен.
/// В случае возникновения различных ошибок открытия файла, совершает повторные попытки.
/// Например, если файл занят другим приложением.
/// В случае возникновения какой-либо ошибки, во время открытия файла, попытки его открыть будут продолжаться каждые 100 мс, в течение пяти секунд.
/// Если ни одна попытка не была успешной, метод выдаст исключение <see cref="FileNotFoundException"/>.
/// При обработке исключений необходимо проверять свойство <see cref="Exception.InnerException"/>, т.к. в нём находится первоначальное исключение.
/// После считывания изображения, метод выполняет проверку значения <see cref="Color.A"/> в считанном изображении, с помощью метода <see cref="CheckBitmapByAlphaColor(Bitmap)"/>, который, в случае неудачной проверки, выбрасывает исключение <see cref="InvalidOperationException"/>.
/// Метод открывает файл (<paramref name="fullPath"/>) на чтение, с флагом <see cref="FileShare.Read"/>.
/// </remarks>
/// <exception cref="FileNotFoundException"/>
/// <exception cref="InvalidOperationException"/>
/// <seealso cref="FrmExample.DefaultOpacity"/>
/// <seealso cref="FrmExample.CheckAlphaColor(Color)"/>
/// <seealso cref="CheckBitmapByAlphaColor(Bitmap)"/>
protected static Bitmap ReadBitmap(string fullPath)
{
if (string.IsNullOrEmpty(fullPath))
throw new ArgumentNullException(nameof(fullPath), $@"{nameof(ReadBitmap)}: Путь должен быть указан.");
FileStream fs = null;
for (int k = 0; k < 50; k++)
{
try
{
fs = new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
}
catch (Exception ex)
{
if (k > 48)
throw new FileNotFoundException($@"{nameof(ReadBitmap)}: {ex.Message}", fullPath, ex);
Thread.Sleep(100);
continue;
}
break;
}
if (fs == null)
throw new InvalidOperationException($@"{nameof(ReadBitmap)}: {nameof(fs)} = null{Environment.NewLine}Путь: {fullPath}.");
try
{
using (fs)
{
Bitmap btm = new Bitmap(fs);
try
{
return CheckBitmapByAlphaColor(btm);
}
catch
{
btm.Dispose();
throw;
}
}
}
catch (Exception ex)
{
throw new InvalidOperationException($@"{nameof(ReadBitmap)}: {ex.Message}{Environment.NewLine}Путь: {fullPath}.", ex);
}
}
/// <summary>
/// Добавляет указанную карту <see cref="Processor" /> в <see cref="ConcurrentProcessorStorage" />.
/// Добавляет её как в коллекцию, идентифицирующую карты по <paramref name="hashCode"/>, так и в коллекцию, идентифицирующую карты по путям к ним.
/// <paramref name="hashCode"/> добавляемой карты может совпадать с <paramref name="hashCode"/> других карт.
/// Полный путь к добавляемой карте на существование не проверяется.
/// Если карта уже присутствовала в коллекции, то она будет перезагружена в неё.
/// </summary>
/// <param name="hashCode">Хеш добавляемой карты.</param>
/// <param name="fullPath">Полный путь к добавляемой карте.</param>
/// <param name="processor">Добавляемая карта <see cref="Processor" />.</param>
/// <remarks>
/// На эту операцию влияет флаг <see cref="LongOperationsAllowed"/>.
/// </remarks>
protected virtual void ReplaceElement(int hashCode, string fullPath, Processor processor)
{
RemoveProcessor(fullPath);
if (!LongOperationsAllowed)
return;
BaseAddElement(hashCode, fullPath, processor);
}
/// <summary>
/// Базовая функция для добавления указанной карты в <see cref="ConcurrentProcessorStorage" />.
/// </summary>
/// <param name="hashCode">Хеш добавляемой карты.</param>
/// <param name="fullPath">Полный путь к добавляемой карте.</param>
/// <param name="processor">Добавляемая карта.</param>
/// <remarks>
/// Этот метод добавляет <paramref name="processor"/> в оба хранилища: <see cref="DictionaryByKey"/> и <see cref="DictionaryByHash"/>.
/// Обрабатывает случай, когда <paramref name="hashCode"/> добавляемой карты совпадает с <paramref name="hashCode"/> других карт.
/// В случае совпадения указанного <paramref name="fullPath"/> с <paramref name="fullPath"/> другой карты (без учёта регистра), возникает исключение <see cref="ArgumentException"/>, а состояние <see cref="ConcurrentProcessorStorage" /> не изменится.
/// НЕ является потокобезопасным. Никаких проверок (в том числе, аргументов) не производит.
/// При некорректных значениях аргументов поведение метода неопределено.
/// </remarks>
/// <exception cref="ArgumentException"/>
protected void BaseAddElement(int hashCode, string fullPath, Processor processor)
{
DictionaryByKey.Add(GetStringKey(fullPath), new ProcPath(processor, fullPath));
if (DictionaryByHash.TryGetValue(hashCode, out ProcHash ph))
ph.AddProcessor(new ProcPath(processor, fullPath));
else
DictionaryByHash.Add(hashCode, new ProcHash(new ProcPath(processor, fullPath)));
}
/// <summary>
/// Получает карту по указанному индексу.
/// </summary>
/// <param name="index">
/// Индекс карты <see cref="Processor" />, которую необходимо получить. В случае допустимого
/// изначального значения, это значение остаётся прежним, иначе равняется индексу последней карты в коллекции.
/// </param>
/// <returns>Возвращает карту, путь к ней, и количество карт в коллекции.</returns>
/// <remarks>
/// Путь, по которому располагается выбранная карта, сохраняется в свойстве <see cref="SelectedPath"/>.
/// В случае недопустимого значения индекса карты возвращается последняя карта.
/// В случае отсутствия карт в коллекции будут возвращены следующие значения: (<see langword="null" />, <see cref="string.Empty" />, 0), <paramref name="index"/> будет равен нолю.
/// </remarks>
/// <seealso cref="SelectedIndex"/>
/// <seealso cref="IsSelectedOne"/>
public (Processor processor, string path, int count) GetLatestProcessor(ref int index)
{
lock (SyncObject)
{
if (IsEmpty)
{
index = 0;
return (null, string.Empty, 0);
}
int count = Count;
if (index < 0 || index >= count)
index = count - 1;
(Processor processor, string path, _) = this[index];
SelectedPath = path;
return (processor, path, count);
}
}
/// <summary>
/// Получает карту по указанному индексу.
/// </summary>
/// <param name="index">
/// Индекс карты <see cref="Processor" />, которую необходимо получить. В случае допустимого
/// изначального значения, это значение остаётся прежним, иначе равняется индексу первой карты в коллекции.
/// </param>
/// <param name="useLastIndex">
/// Если значение <see langword="true" />, то значение параметра <paramref name="index"/> будет считано из свойства <see cref="SelectedIndex"/>.
/// Если свойство <see cref="SelectedIndex"/> сброшено, то будут возвращены следующие значения: (<see langword="null" />, <see cref="SelectedPath" />, <see cref="Count" />), значение параметра <paramref name="index"/> останется прежним.
/// </param>
/// <returns>Возвращает карту, путь к ней, и количество карт в коллекции.</returns>
/// <remarks>
/// Путь, по которому располагается выбранная карта, сохраняется в свойстве <see cref="SelectedPath"/>.
/// В случае недопустимого значения индекса карты возвращается первая карта.
/// В случае отсутствия карт в коллекции будут возвращены следующие значения: (<see langword="null" />, <see cref="SelectedPath" />, 0), <paramref name="index"/> будет равен нолю.
/// </remarks>
/// <seealso cref="SelectedIndex"/>
/// <seealso cref="IsSelectedOne"/>
public (Processor processor, string path, int count) GetFirstProcessor(ref int index, bool useLastIndex = false)
{
lock (SyncObject)
{
if (IsEmpty)
{
index = 0;
return (null, SelectedPath, 0);
}
int count = Count;
if (useLastIndex)
{
int lastIndex = SelectedIndex;
if (lastIndex < 0)
return (null, SelectedPath, count);
index = lastIndex;
}
if (index < 0 || index >= count)
index = 0;
(Processor processor, string path, _) = this[index];
SelectedPath = path;
return (processor, path, count);
}
}
/// <summary>
/// Получает значение, отражающее фактическое существование выбранной карты на жёстком диске.
/// </summary>
/// <returns>
/// Если файл существует, возвращает ("путь к файлу", <see langword="true"/>), в противном случае - ("путь к файлу", <see langword="false"/>).
/// Если свойство <see cref="SelectedPath"/> сброшено, вернёт (<see cref="string.Empty"/>, <see langword="false"/>).
/// </returns>
/// <remarks>
/// Является потокобезопасным.
/// Считывает свойство <see cref="SelectedPath"/>.
/// Обращается к файловой системе.
/// </remarks>
/// <seealso cref="SelectedPath"/>
public (string path, bool isExists) IsSelectedPathExists()
{
string path = SelectedPath;
return (path, !string.IsNullOrEmpty(path) && new FileInfo(path).Exists);
}
/// <summary>
/// Удаляет указанную карту (или папку с картами) из коллекции <see cref="ConcurrentProcessorStorage" />,
/// идентифицируя её по пути к ней.
/// </summary>
/// <param name="fullPath">Полный путь к карте (или к папке с картами), которую необходимо удалить из коллекции.</param>
/// <returns>
/// В случае, если была найдена и удалена хотя бы одна карта, возвращает значение <see langword="true" />.
/// Если операция была отменена с помощью флага <see cref="LongOperationsAllowed"/>, метод всегда возвращает значение <see langword="false" />.
/// По этой же причине, не все карты могут быть удалены, т.к. неизвестно, на каком этапе операция была прервана.
/// </returns>
/// <remarks>
/// Является потокобезопасным.
/// Если указан путь к папке (<see cref="IsDirectory(string)"/>), то будут удалены все карты, содержащиеся в ней (в том числе, во вложенных папках).
/// В случае, если удаляемая (указанная) карта является выбранной в данный момент, свойство <see cref="SelectedPath"/> будет сброшено.
/// В случае, если указан путь к папке, поиск производится по соответствию части строки, без учёта регистра.
/// Если требуется произвести удаление карт из строго определённой папки, необходимо поставить разделитель каталогов в конце пути.
/// Для этого рекомендуется воспользоваться методом <see cref="AddEndingSlash(string)"/>.
/// </remarks>
/// <seealso cref="IsDirectory(string)"/>
/// <seealso cref="SelectedPath"/>
/// <seealso cref="SelectedIndex"/>
/// <seealso cref="AddEndingSlash(string)"/>
public bool RemoveProcessor(string fullPath)
{
if (string.IsNullOrEmpty(fullPath))
return false;
lock (SyncObject)
{
if (!IsDirectory(fullPath))
return RemoveProcessor(this[fullPath].processor);
if (!LongOperationsAllowed)
return false;
Processor[] arrNeedRemove = DictionaryByKey.Keys.TakeWhile(_ => LongOperationsAllowed)
.Where(x => x.StartsWith(fullPath, StringComparison.OrdinalIgnoreCase))
.Select(path => this[path].processor).ToArray();
if (!LongOperationsAllowed)
return false;
bool result = false;
foreach (Processor p in arrNeedRemove)
{
if (!LongOperationsAllowed)
return false;
if (RemoveProcessor(p))
result = true;
}
return result;
}
}
/// <summary>
/// Получает значение, отражающее, является ли указанный путь приемлимым в качестве пути к карте.
/// </summary>
/// <param name="path">Проверяемый путь.</param>
/// <returns>
/// Если указанный путь является приемлимым в качестве пути к карте, возвращает значение <see langword="true" />.
/// Если входная строка пустая (<see langword="null" /> или <see cref="string.Empty" />), возвращает значение <see langword="false" />.
/// </returns>
/// <remarks>
/// Метод проверяет только расширение.
/// Путь обязательно должен содержать хотя бы один разделитель (<see cref="Path.DirectorySeparatorChar"/> или <see cref="Path.AltDirectorySeparatorChar"/>).
/// Расширение должно быть <see cref="ExtImg"/>.
/// Регистр символов расширения не имеет значения.
/// К файловой системе не обращается.
/// Метод потокобезопасный.
/// </remarks>
/// <seealso cref="ExtImg"/>
/// <seealso cref="Path.DirectorySeparatorChar"/>
/// <seealso cref="Path.AltDirectorySeparatorChar"/>
public bool IsProcessorFile(string path)
{
return !string.IsNullOrEmpty(path) &&
string.Compare(Path.GetExtension(path), $".{ExtImg}", StringComparison.OrdinalIgnoreCase) == 0;
}
/// <summary>
/// Проверяет, указывает ли заданный путь на директорию.
/// </summary>
/// <param name="path">Проверяемый путь.</param>
/// <returns>Если <paramref name="path"/> указывает на директорию, метод возвращает значение <see langword="true" />.</returns>
/// <remarks>
/// Входная строка может быть <see langword="null" /> или <see cref="string.Empty" />, в этом случае метод возвращает значение <see langword="false" />.
/// Для увеличения производительности метода, на конце строки следует использовать разделитель каталогов (<see cref="Path.DirectorySeparatorChar"/>).
/// Если в конце строки символ-разделитель отсутствует, метод ищет расширение. Если оно отсутствует, то считается, что строка пути указывает на каталог.
/// Метод является потокобезопасным.
/// К файловой системе не обращается.
/// Для определения наличия символа-разделителя каталогов на конце строки пути, использует метод <see cref="IsDirectorySeparatorSymbol(char)"/>.
/// </remarks>
/// <seealso cref="IsDirectorySeparatorSymbol(char)"/>
public static bool IsDirectory(string path)
{
return !string.IsNullOrEmpty(path) && (IsDirectorySeparatorSymbol(path[path.Length - 1]) ||
string.IsNullOrEmpty(Path.GetExtension(path)));
}
/// <summary>
/// Получает ключ для хранения элемента в коллекции <see cref="ConcurrentProcessorStorage"/>.
/// </summary>
/// <param name="path">Путь к элементу, для которого необходимо сформировать ключ.</param>
/// <returns>Возвращает ключ в виде строки.</returns>
/// <remarks>
/// Если <paramref name="path"/> пустой (<see langword="null" /> или <see cref="string.Empty" />), метод вернёт <see cref="string.Empty"/>.
/// Ключ представляет собой параметр <paramref name="path"/>, обработанный методом <see cref="string.ToLower()"/>.
/// Метод потокобезопасен.
/// </remarks>
protected static string GetStringKey(string path)
{
return string.IsNullOrEmpty(path) ? string.Empty : path.ToLower();
}
/// <summary>
/// Получает хеш-код указанной карты.
/// </summary>
/// <param name="processor">Карта, хеш-код которой требуется получить.</param>
/// <returns>Хеш-код указанной карты.</returns>
/// <remarks>
/// Метод потокобезопасен.
/// Для получения дополнительных сведений см. класс <see cref="CRCIntCalc"/>.
/// Для генерации хеш-кода используется только тело карты, значение свойства <see cref="Processor.Tag"/> не принимается во внимание.
/// </remarks>
/// <seealso cref="CRCIntCalc"/>
/// <seealso cref="Processor.Tag"/>
static int GetHashCode(Processor processor)
{
if (processor == null)
throw new ArgumentNullException(nameof(processor), @"Для получения хеша карты необходимо её указать.");
return CRCIntCalc.GetHash(processor);
}
/// <summary>
/// Удаляет указанную карту <see cref="Processor" /> из коллекции <see cref="ConcurrentProcessorStorage" />.
/// </summary>
/// <param name="processor">Карта <see cref="Processor" />, которую следует удалить.</param>
/// <remarks>
/// Является потокобезопасным.
/// В случае, если указанная карта является выбранной в данный момент, свойство <see cref="SelectedPath"/> будет сброшено.
/// </remarks>
/// <returns>В случае успешного удаления карты возвращает значение <see langword="true" />.</returns>
/// <seealso cref="SelectedPath"/>
/// <seealso cref="SelectedIndex"/>
bool RemoveProcessor(Processor processor)
{
if (processor == null)
return false;
int hashCode = GetHashCode(processor);
bool result = false;
lock (SyncObject)
{
if (!DictionaryByHash.TryGetValue(hashCode, out ProcHash ph))
return false;
int index = 0;
foreach (ProcPath px in ph.Elements)
if (ReferenceEquals(processor, px.CurrentProcessor))
{
string path = ph[index].CurrentPath;
result = DictionaryByKey.Remove(GetStringKey(path));
result &= ph.RemoveProcessor(index);
if (string.Compare(path, SelectedPath, StringComparison.OrdinalIgnoreCase) == 0)
SelectedPath = string.Empty;
SelectedIndex = -1;
break;
}
else
{
index++;
}
if (!ph.Elements.Any())
DictionaryByHash.Remove(hashCode);
}
return result;
}
/// <summary>
/// Удаляет всё содержимое коллекции <see cref="ConcurrentProcessorStorage"/>.
/// </summary>
/// <remarks>
/// Не затрагивает свойство <see cref="LongOperationsAllowed"/>.
/// Является потокобезопасным.
/// </remarks>
/// <seealso cref="LongOperationsAllowed"/>
public void Clear()
{
lock (SyncObject)
{
DictionaryByKey.Clear();
DictionaryByHash.Clear();
SelectedPath = string.Empty;
}
}
/// <summary>
/// Сохраняет изображение по указанному пути.
/// </summary>
/// <param name="btm">Изображение, которое требуется сохранить.</param>
/// <param name="path">
/// Абсолютный путь, по которому требуется сохранить изображение. Если путь относительный, то
/// используется <see cref="WorkingDirectory" />.
/// </param>
/// <remarks>
/// Является потокобезопасным.
/// Изображение всегда будет сохранено с расширением <see cref="ExtImg"/>, в формате <see cref="ImageFormat.Bmp"/>.
/// </remarks>
protected void SaveToFile(Bitmap btm, string path)
{
if (btm == null)
throw new ArgumentNullException(nameof(btm), $@"{nameof(SaveToFile)}: Необходимо указать изображение, которое требуется сохранить.");
if (string.IsNullOrWhiteSpace(path))
throw new ArgumentException($@"{nameof(SaveToFile)}: Путь, по которому требуется сохранить изображение, не задан.", nameof(path));
string resultTmp, result;
try
{
path = Path.ChangeExtension(path, string.Empty);
resultTmp = Path.Combine(WorkingDirectory, Path.ChangeExtension(path, @"saveTMP"));
result = Path.Combine(WorkingDirectory, Path.ChangeExtension(path, ExtImg));
using (FileStream fs = new FileStream(resultTmp, FileMode.Create, FileAccess.Write))
btm.Save(fs, ImageFormat.Bmp);
}
catch (Exception ex)
{
throw new Exception($@"{nameof(SaveToFile)}: Неизвестная ошибка при сохранении карты (1): {ex.Message}", ex);
}
try
{
File.Delete(result);
File.Move(resultTmp, result);
}
catch (FileNotFoundException ex)
{
throw new Exception($@"{nameof(SaveToFile)}: Ошибка при сохранении карты: {resultTmp}: {ex.Message}", ex);
}
catch (IOException ex)
{
throw new Exception($@"{nameof(SaveToFile)}: Попытка перезаписать существующий файл: {result}: {ex.Message}", ex);
}
catch (Exception ex)
{
throw new Exception($@"{nameof(SaveToFile)}: Неизвестная ошибка при сохранении карты (2): {ex.Message}", ex);
}
}
/// <summary>
/// Хранит карту <see cref="Processor" /> и путь <see cref="string" /> к ней.
/// </summary>
protected readonly struct ProcPath
{
/// <summary>
/// Хранимая карта.
/// </summary>
public Processor CurrentProcessor { get; }
/// <summary>
/// Путь к карте <see cref="Processor" />.
/// </summary>
public string CurrentPath { get; }
/// <summary>
/// Инициализирует хранимые объекты: <see cref="Processor" /> и <see cref="string" />.
/// </summary>
/// <param name="p">Хранимая карта.</param>
/// <param name="path">Путь к карте <see cref="Processor" />.</param>
public ProcPath(Processor p, string path)
{
if (string.IsNullOrWhiteSpace(path))
throw new ArgumentException($@"{nameof(ProcPath)} (конструктор): Параметр {nameof(path)} не может быть пустым.", nameof(path));
CurrentProcessor =
p ?? throw new ArgumentNullException(nameof(p), $@"{nameof(ProcPath)} (конструктор): {nameof(p)} не может быть равен null.");
CurrentPath = path;
}
}
/// <summary>
/// Хранит карты, которые соответствуют одному значению хеша.
/// </summary>
protected readonly struct ProcHash
{
/// <summary>
/// Список хранимых карт, дающих одно значение хеша.
/// </summary>
readonly List<ProcPath> _lst;
/// <summary>
/// Конструктор, который добавляет одну карту по умолчанию.
/// Значение не может быть равно <see langword="null" />.
/// </summary>
/// <param name="p">Добавляемая карта.</param>
public ProcHash(ProcPath p)
{
if (p.CurrentProcessor == null || string.IsNullOrWhiteSpace(p.CurrentPath))
throw new ArgumentNullException(nameof(p), $@"Функция (конструктор) {nameof(ProcHash)}.");
_lst = new List<ProcPath> { p };
}
/// <summary>
/// Добавляет одну карту в коллекцию.
/// Значение не может быть равно <see langword="null" />.
/// </summary>
/// <param name="p">Добавляемая карта.</param>
public void AddProcessor(ProcPath p)
{
if (p.CurrentProcessor == null || string.IsNullOrWhiteSpace(p.CurrentPath))
throw new ArgumentNullException(nameof(p), $@"Функция {nameof(AddProcessor)}.");
_lst.Add(p);
}
/// <summary>
/// Получает все хранимые карты в текущем экземпляре <see cref="ProcHash" />.
/// </summary>
public IEnumerable<ProcPath> Elements => _lst;
/// <summary>
/// Получает <see cref="ProcHash" /> по указанному индексу.
/// </summary>
/// <param name="index">Индекс элемента <see cref="ProcHash" />, который требуется получиться.</param>
/// <returns>Возвращает <see cref="ProcHash" /> по указанному индексу.</returns>
public ProcPath this[int index] => _lst[index];
/// <summary>
/// Удаляет элемент <see cref="ProcPath"/> из коллекции <see cref="ProcHash"/>, с указанным индексом.
/// </summary>
/// <param name="index">Индекс карты, которую требуется удалить.</param>
/// <returns>В случае успешного удаления карты возвращает значение <see langword="true" />.</returns>
/// <remarks>
/// НЕ является потокобезопасным.
/// В случае недопустимого значения параметра <paramref name="index"/> возвращает значение <see langword="false" />.
/// </remarks>
public bool RemoveProcessor(int index)
{
if (index < 0 || index >= _lst.Count)
return false;
_lst.RemoveAt(index);
return true;
}
}
/// <summary>
/// Предназначен для вычисления хеша определённой последовательности чисел типа <see cref="int" />.
/// </summary>
static class CRCIntCalc
{
/// <summary>
/// Таблица значений для расчёта хеша.
/// Вычисляется по алгоритму Далласа Максима (полином равен 49 (0x31).
/// </summary>
static readonly int[] Table;
/// <summary>
/// Статический конструктор, рассчитывающий таблицу значений <see cref="Table" /> по алгоритму Далласа Максима (полином
/// равен 49 (0x31).
/// </summary>
static CRCIntCalc()
{
int[] numArray = new int[256];
for (int index1 = 0; index1 < 256; ++index1)
{
int num = index1;
for (int index2 = 0; index2 < 8; ++index2)
if ((uint)(num & 128) > 0U)
num = (num << 1) ^ 49;
else
num <<= 1;
numArray[index1] = num;
}
Table = numArray;
}
/// <summary>
/// Получает хеш заданной карты.
/// Карта не может быть равна <see langword="null" />.
/// </summary>
/// <param name="p">Карта, для которой необходимо вычислить значение хеша.</param>
/// <returns>Возвращает хеш заданной карты.</returns>
public static int GetHash(Processor p)
{
if (p == null)
throw new ArgumentNullException(nameof(p), $@"Функция {nameof(GetHash)}.");
return GetHash(GetInts(p));
}
/// <summary>
/// Получает значения элементов карты построчно.
/// </summary>
/// <param name="p">Карта, с которой необходимо получить значения элементов.</param>
/// <returns>Возвращает значения элементов карты построчно.</returns>
static IEnumerable<int> GetInts(Processor p)
{
if (p == null)
throw new ArgumentNullException(nameof(p), $@"Функция {nameof(GetInts)}.");
for (int j = 0; j < p.Height; j++)
for (int i = 0; i < p.Width; i++)
yield return p[i, j].Value;
}
/// <summary>
/// Получает значение хеша для заданной последовательности целых чисел <see cref="int" />.
/// </summary>
/// <param name="ints">Последовательность, для которой необходимо рассчитать значение хеша.</param>
/// <returns>Возвращает значение хеша для заданной последовательности целых чисел <see cref="int" />.</returns>
static int GetHash(IEnumerable<int> ints)
{
if (ints == null)
throw new ArgumentNullException(nameof(ints),
$@"Для подсчёта контрольной суммы необходимо указать массив байт. Функция {nameof(GetHash)}.");
return ints.Aggregate(255, (current, t) => Table[(byte)(current ^ t)]);
}
}
}
}
|
f5d754fcb0e01478561ca0a9587d00339623e4ad
|
C#
|
ddrempe/uzdiz
|
/damdrempe_zadaca_2/damdrempe_zadaca_2/Sustav/Pomocno.cs
| 2.6875
| 3
|
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace damdrempe_zadaca_2.Sustav
{
class Pomocno
{
public static void ZavrsiProgram(string sadrzajPoruke, bool uspjeh)
{
string porukaZavrsetka = uspjeh ? "USPJEH! " : "GRESKA! ";
porukaZavrsetka += sadrzajPoruke;
Console.WriteLine(porukaZavrsetka);
Console.ReadKey();
Environment.Exit(0);
}
public static string DohvatiPutanjuDatoteke(string nazivDatoteke)
{
return Path.Combine(Program.PutanjaDatoteka, nazivDatoteke);
}
public static bool DioPodrucjaJeUlica(string dioID)
{
return dioID.StartsWith("u") ? true : false;
}
}
}
|
ba5c7fcb7b93146945bfa66338472bbdbc9dc08c
|
C#
|
codeacademymktoni/RestaurantManagement
|
/Repositories/TableRepository.cs
| 2.765625
| 3
|
using Microsoft.EntityFrameworkCore;
using RestorantManagement.Models;
using RestorantManagement.Repositories.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace RestorantManagement.Repositories
{
public class TableRepository : ITableRepository
{
private readonly RestorantManagementDbContext context;
public TableRepository(RestorantManagementDbContext context )
{
this.context = context;
}
public List<Table> GetAll()
{
return context.Tables.ToList();
}
public Table GetById(int tableId)
{
return context.Tables
.Include(x => x.Receipts)
.ThenInclude(x => x.ProductReceipts)
.ThenInclude(x => x.Product)
.FirstOrDefault(x => x.Id == tableId);
}
public void Update(Table table)
{
context.Tables.Update(table);
context.SaveChanges();
}
}
}
|
a4b02d12017d7174b02b5efc463ff9d5e62ce5b9
|
C#
|
Dream2Sky/JCB
|
/com.jiechengbao.common/TimeManager.cs
| 2.78125
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace com.jiechengbao.common
{
public class TimeManager
{
protected static readonly DateTime unixTPStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
/// <summary>
/// 获取当前时间戳
/// </summary>
/// <returns></returns>
public static long GetCurrentTimestamp()
{
try
{
TimeSpan toNow = DateTime.Now.Subtract(unixTPStart);
return (long)Math.Round(toNow.TotalSeconds);
}
catch (Exception ex)
{
LogHelper.Log.Write(ex.Message);
LogHelper.Log.Write(ex.StackTrace);
throw;
}
}
}
}
|
118bb21d6325cda53a32f7bf20a2e327005bda31
|
C#
|
shendongnian/download4
|
/code6/1123189-29610135-88011962-2.cs
| 2.75
| 3
|
using (var ms = new MemoryStream())
{
using (var doc = new Document(PageSize.A4, 50, 50, 25, 25)) {
//Create a writer that's bound to our PDF abstraction and our stream
using (var writer = PdfWriter.GetInstance(doc, ms))
{
//Open the document for writing
doc.Open();
var courier9RedFont = FontFactory.GetFont("Courier", 9, BaseColor.RED);
var importantNotice = new Paragraph("Sit on a potato pan Otis - if you don't agree that that's the best palindrome ever, I will sic Paladin on you, or at least say, 'All down but nine - set 'em up on the other alley, pard'", courier9RedFont);
importantNotice.Leading = 0;
importantNotice.MultipliedLeading = 0.9F; // reduce the width between lines in the paragraph with these two settings
// Add a single-cell, borderless, left-aligned, half-page, table
PdfPTable table = new PdfPTable(1);
PdfPCell cellImportantNote = new PdfPCell(importantNotice);
cellImportantNote.BorderWidth = PdfPCell.NO_BORDER;
table.WidthPercentage = 50;
table.HorizontalAlignment = Element.ALIGN_LEFT;
table.AddCell(cellImportantNote);
doc.Add(table);
doc.Close();
}
var bytes = ms.ToArray();
String PDFTestOutputFileName = String.Format("iTextSharp_{0}.pdf", DateTime.Now.ToShortTimeString());
PDFTestOutputFileName = PDFTestOutputFileName.Replace(":", "_");
var testFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), PDFTestOutputFileName);
File.WriteAllBytes(testFile, bytes);
MessageBox.Show(String.Format("{0} written", PDFTestOutputFileName));
}
}
|
efee09a642627783f7d3300576d4cc74769b3cfb
|
C#
|
RosarioBrancato/DataInserter
|
/DataInserter/DTO/ReportMessage.cs
| 2.875
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace DataInserter.DTO {
public class ReportMessage {
public bool Success { get; set; }
public string Message { get; set; }
public ReportStatus Status { get; set; }
public ReportMessage(bool success, string message, ReportStatus status) {
this.Success = success;
this.Message = message;
this.Status = status;
}
public MessageBoxIcon GetIconOfStatus() {
switch(this.Status) {
case ReportStatus.Info:
return MessageBoxIcon.Information;
case ReportStatus.Success:
return MessageBoxIcon.Information;
case ReportStatus.Warning:
return MessageBoxIcon.Warning;
case ReportStatus.Error:
return MessageBoxIcon.Error;
default:
return MessageBoxIcon.None;
}
}
}
public enum ReportStatus {
Info,
Success,
Warning,
Error
}
}
|
a598d5ce7cfa35574496e96009699b129d1650f7
|
C#
|
mili-tan/Something
|
/jwt.cs
| 2.71875
| 3
|
using System;
using JWT.Algorithms;
using JWT.Builder;
using Newtonsoft.Json.Linq;
namespace JWToken
{
class Program
{
static void Main(string[] args)
{
var secret = Guid.NewGuid();
var token = new JwtBuilder()
.WithAlgorithm(new HMACSHA256Algorithm())
.WithSecret(secret.ToString())
.ExpirationTime(DateTimeOffset.UtcNow.AddHours(24).ToUnixTimeSeconds())
.IssuedAt(DateTime.Now)
.AddClaim("token", secret)
.Encode();
Console.WriteLine(token);
var json = new JwtBuilder()
.WithAlgorithm(new HMACSHA256Algorithm())
.WithSecret(secret.ToString())
.MustVerifySignature()
.Decode<JObject>(token);
Console.WriteLine(json["token"].ToString());
}
}
}
|
90b50a4fb0e87d9af5f6467749ebeca59563ee3a
|
C#
|
CrazyBread/TextAnalyzer
|
/TA.Claster/ClasterizeBigram.cs
| 3.09375
| 3
|
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace TA.Claster
{
public class ClasterizeBigram
{
const int DIMENSIONS = 3;
private Claster _termClaster = new Claster("Термин", DIMENSIONS);
private Claster _notTermClaster = new Claster("Не термин", DIMENSIONS);
private string _text;
private List<ClasterItem> _items;
private List<ClasterAccessory> _accessories;
private float _m;
public ClasterizeBigram(string text, List<ClasterItem> items)
{
_text = text;
_items = items;
_accessories = new List<ClasterAccessory>();
_accessories.AddRange(_items.Select(i => new ClasterAccessory() { Claster = _termClaster, Item = i, Accessory = 0.0F }));
_accessories.AddRange(_items.Select(i => new ClasterAccessory() { Claster = _notTermClaster, Item = i, Accessory = 0.0F }));
}
/// <summary>
/// Запускает механизм кластеризации
/// </summary>
/// <param name="m">Степень нечёткости кластеризации (от 1 до 2)</param>
public void Run(float m = 1.5F, int maxIterations = 1000, float eps = 0.001F)
{
_m = m;
_Init();
for (int stepCounter = 0; stepCounter < maxIterations; stepCounter++)
{
_CalculateCentres();
_CalculateAccessories();
var maxEps = _GetMaxEps();
if (maxEps < eps)
break;
}
}
public void PrintResult(string fileName)
{
var top50Terms = _accessories.Where(i => i.Claster == _termClaster).OrderByDescending(i => i.Accessory).Take(50);
var top50NotTerms = _accessories.Where(i => i.Claster == _notTermClaster).OrderByDescending(i => i.Accessory).Take(50);
Trace.Listeners.Add(new TextWriterTraceListener(fileName));
Trace.WriteLine("ТОП 50 терминов:");
foreach(var item in top50Terms)
{
Trace.WriteLine(item.Item.Item);
}
Trace.WriteLine("");
Trace.WriteLine("ТОП 50 не терминов:");
foreach (var item in top50NotTerms)
{
Trace.WriteLine(item.Item.Item);
}
Trace.Flush();
}
public List<string> GetTerms(int count)
{
return _accessories.Where(i => i.Claster == _termClaster).OrderByDescending(i => i.Accessory).Take(count).Select(d => d.Item.Item as string).ToList();
}
public List<string> GetNotTerms(int count)
{
return _accessories.Where(i => i.Claster == _notTermClaster).OrderByDescending(i => i.Accessory).Take(count).Select(d => d.Item.Item as string).ToList();
}
private void _Init()
{
for (int i = 0; i < _termClaster.Dimensions; i++)
{
var minValue = _items.Min(j => j.GetValue(i));
var maxValue = _items.Max(j => j.GetValue(i));
_notTermClaster.SetCentre(i, minValue);
_termClaster.SetCentre(i, maxValue);
}
_CalculateAccessories();
}
private void _CalculateCentres()
{
_CalculateCentre(_termClaster);
_CalculateCentre(_notTermClaster);
}
private void _CalculateCentre(Claster claster)
{
var tmpAcessories = _accessories.Where(i => i.Claster == claster);
var denomSum = tmpAcessories.Sum(i => Math.Pow(i.Accessory, _m));
for (int i = 0; i < claster.Dimensions; i++)
{
var numSum = tmpAcessories.Sum(j => Math.Pow(j.Accessory, _m) * j.Item.GetValue(i));
claster.SetCentre(i, numSum / denomSum);
}
}
private void _CalculateAccessories()
{
foreach(var a in _accessories)
{
double denom = 0.0F;
denom += _CalculateAccessory(_termClaster, a);
denom += _CalculateAccessory(_notTermClaster, a);
a.Accessory = 1 / denom;
}
}
private double _CalculateAccessory(Claster claster, ClasterAccessory accessory)
{
double result = 0.0F;
var neededAccessory = _accessories.First(i => i.Item == accessory.Item && i.Claster == claster);
result = accessory.FitnessValue / neededAccessory.FitnessValue;
result = Math.Pow(result, _m * 2);
return result;
}
private double _GetMaxEps()
{
double maxEps = 0.0F;
foreach (var accessory in _accessories)
{
if (Math.Abs(accessory.Accessory - accessory.AccessoryOld) > maxEps)
maxEps = Math.Abs(accessory.Accessory - accessory.AccessoryOld);
}
return maxEps;
}
}
}
|
af7e902320937d66afbb54be417c940950d71a7f
|
C#
|
Coco-s/Nik_proj_1
|
/Nik_proj_1/Program.cs
| 3.640625
| 4
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Nik_proj_1
{
class Program
{
static bool Prost(int value)
{
bool flag = true;
for (int i = 2; i <= value / 2; i++)
{
if (value % i == 0)
{
flag = false;
break;
}
}
return flag;
}
static int NProst(int value)
{
int pnext = value + 1;
if (Prost(value))
{
while (!Prost(pnext))
{
pnext += 1;
}
return pnext;
}
else return -1;
}
static void Main(string[] args)
{
bool fl = true;
int anch = 0;
int pnext = 0;
int plast = 0;
Console.WriteLine("Введите число\n");
int ch = int.Parse(Console.ReadLine());
for (int i = 2; i <= ch / 2; i++)
{
if (ch % i == 0 && fl == true)
{
anch = i;
fl = false;
}
}
int first = anch;
pnext = NProst(anch);
if (ch % pnext == 0)
{
anch = pnext;
}
plast = NProst(pnext);
if (ch % plast == 0)
{
Console.WriteLine("Succes");
Console.WriteLine(first);
Console.WriteLine(pnext);
Console.WriteLine(plast);
}
else Console.WriteLine("Sosat'!");
}
}
}
|
9b861a4eefc24897f15eaecf7797c6d1c3d7f90a
|
C#
|
GitHubLyf/NSqlParser
|
/NSqlParser/NSqlParser/Statement/Create/Table/CreateTable.cs
| 2.71875
| 3
|
using System.Collections.Generic;
using NSqlParser.Statement.Select;
namespace NSqlParser.Statement.Create.Table
{
public class CreateTable : IStatement
{
private Schema.Table table;
private bool unlogged = false;
private List<string> createOptionsstrings;
private List<string> tableOptionsstrings;
private List<ColumnDefinition> columnDefinitions;
private List<Index> indexes;
private Select.Select select;
public void Accept(IStatementVisitor statementVisitor)
{
statementVisitor.Visit(this);
}
/**
* The name of the table to be created
*/
public Schema.Table getTable()
{
return table;
}
public void setTable(Schema.Table table)
{
this.table = table;
}
/**
* Whether the table is unlogged or not (PostgreSQL 9.1+ feature)
* @return
*/
public bool isUnlogged() { return unlogged; }
public void setUnlogged(bool unlogged) { this.unlogged = unlogged; }
/**
* A list of {@link ColumnDefinition}s of this table.
*/
public List<ColumnDefinition> getColumnDefinitions()
{
return columnDefinitions;
}
public void setColumnDefinitions(List<ColumnDefinition> list)
{
columnDefinitions = list;
}
/**
* A list of options (as simple strings) of this table definition, as
* ("TYPE", "=", "MYISAM")
*/
public List<string> getTableOptionsstrings()
{
return tableOptionsstrings;
}
public void setTableOptionsstrings(List<string> list)
{
tableOptionsstrings = list;
}
public List<string> getCreateOptionsstrings()
{
return createOptionsstrings;
}
public void setCreateOptionsstrings(List<string> createOptionsstrings)
{
this.createOptionsstrings = createOptionsstrings;
}
/**
* A list of {@link Index}es (for example "PRIMARY KEY") of this table.<br>
* Indexes created with column definitions (as in mycol INT PRIMARY KEY) are
* not inserted into this list.
*/
public List<Index> getIndexes()
{
return indexes;
}
public void setIndexes(List<Index> list)
{
indexes = list;
}
public Select.Select getSelect()
{
return select;
}
public void setSelect(Select.Select select)
{
this.select = select;
}
public override string ToString()
{
string sql = "";
string createOps = PlainSelect.getStringList(createOptionsstrings, false, false);
sql = "CREATE " + (unlogged ? "UNLOGGED " : "") +
(!"".Equals(createOps) ? createOps + " " : "") +
"TABLE " + table;
if (select != null)
{
sql += " AS " + select.ToString();
}
else
{
sql += " (";
sql += PlainSelect.getStringList(columnDefinitions, true, false);
if (indexes != null && indexes.Count != 0)
{
sql += ", ";
sql += PlainSelect.getStringList(indexes);
}
sql += ")";
string options = PlainSelect.getStringList(tableOptionsstrings, false, false);
if (options != null && options.Length > 0)
{
sql += " " + options;
}
}
return sql;
}
}
}
|
322104af5793d43dcdd8626443fcc4e7234b66aa
|
C#
|
shendongnian/download4
|
/code11/1965888-59849991-213407795-8.cs
| 2.609375
| 3
|
public IQueryable<SpaceFunctionType> Get<TDomain>(Expression<Func<TDomain, bool>> predicate) where TDomain: IA
{
return _dbContext.Set<TDomain>().Where(predicate.Compile())
.Select(c => new SpaceFunctionType
{
Category = c.Category,
SpaceFunction = c.SpaceFunction
});
|
99b552afd76e19333fe5ee785202eb364c5985fc
|
C#
|
Sbilyanov/SoftUni
|
/C# Fundamentals/7. Associative Arrays-Exersice/CompanyUsers/Program.cs
| 3.328125
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
namespace CompanyUsers
{
class Program
{
static void Main(string[] args)
{
SortedDictionary<string, List<string>> companies = new SortedDictionary<string, List<string>>();
string input = Console.ReadLine();
while (input!="End")
{
string[] array = input.Split("->");
string companyName = array[0];
string employeeID = array[1];
if (!companies.ContainsKey(companyName))
{
companies.Add(companyName, new List<string>());
}
if (!companies[companyName].Contains(employeeID))
{
companies[companyName].Add(employeeID);
}
input = Console.ReadLine();
}
foreach (var item in companies)
{
Console.WriteLine($"{item.Key}");
foreach (var employee in item.Value)
{
Console.WriteLine($"--{employee}");
}
}
}
}
}
|
8124d96129a997991d1e51eadb6ac62b8b6e28b3
|
C#
|
Nima-abdoli/Mink-Player
|
/Mink Player/MusicPath.cs
| 2.53125
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Mink_Player
{
public class MusicPath
{
public string Path { get; set; } // path property for MusicPath Class
}// End of MusicPath Class
/// <summary>
/// Show Player state of player.
/// </summary>
public enum PlayerState { Play, Pause, Empty };
/// <summary>
/// Show Player Mute state of player.
/// </summary>
public enum PlayerMute { Mute,Unmute};
}
|
4fd4caa25d83d1ed172db3dca0b7ebb72dfc8a29
|
C#
|
Qorpent/qorpent.sys
|
/Qorpent.Charts/Graphs/Dot/Types/GraphStyleType.cs
| 2.703125
| 3
|
namespace Qorpent.Graphs.Dot.Types {
/// <summary>
/// Стили узлов
/// </summary>
public enum GraphStyleType {
/// <summary>
/// Сплошная граница графа
/// </summary>
Solid,
/// <summary>
/// Пунктирная граница графа
/// </summary>
Dashed,
/// <summary>
/// Точечная граница графа
/// </summary>
Dotted,
/// <summary>
/// Сплошная жирная граница графа
/// </summary>
Bold,
/// <summary>
/// Округляет углы границ графа
/// </summary>
Rounded,
/// <summary>
/// Заполнение тела графа (серым по умолчанию)
/// </summary>
Filled,
/// <summary>
/// На три сектора разбито тело графа, но у меня не воспроизводится....????
/// </summary>
Striped,
}
}
|
5667cb6a86bfecac7ba6b26911448097859345ad
|
C#
|
grinvi04/TeklaPractice
|
/TeklaCommon/YWControlObject.cs
| 2.921875
| 3
|
using System;
using Tekla.Structures.Dialog;
using TSG = Tekla.Structures.Geometry3d;
using TSM = Tekla.Structures.Model;
namespace TeklaCommon
{
/// <summary>
/// TSM.ModelObject 하위의 참고객체 관련 클래스를 모듈화 한 클래스
/// </summary>
public class YWControlObject
{
/// <summary>
/// 참고객체 점 생성
/// <para>
/// ControlPoint 클래스는 모델링 작업을 돕는 사용자 정의 된 점을 정의합니다.
/// </para>
/// </summary>
/// <param name="existPoint"></param>
/// <returns>ControlPoint Insert Result</returns>
public static bool CreateControlPoint(TSG.Point existPoint)
{
bool isCreate = false;
try
{
TSM.ControlPoint controlPoint = new TSM.ControlPoint(existPoint);
isCreate = controlPoint.Insert();
}
catch (Exception ex)
{
ErrorDialog.Show(ex, ErrorDialog.Severity.ERROR);
}
finally
{
new TSM.Model().CommitChanges();
}
return isCreate;
}
/// <summary>
/// 참고객체 선 생성
/// <para>
/// ControlLine 클래스는 모델링 작업을 돕는 사용자 정의 (가능하면 자기) 선을 정의합니다.
/// </para>
/// </summary>
/// <param name="startPoint"></param>
/// <param name="endPoint"></param>
/// <param name="color"></param>
/// <returns>ControlLine Insert Result</returns>
public static bool CreateControlLine(TSG.Point startPoint, TSG.Point endPoint, TSM.ControlLine.ControlLineColorEnum color)
{
bool isCreate = false;
TSM.ControlLine controlLine = new TSM.ControlLine();
try
{
TSG.LineSegment line = new TSG.LineSegment(startPoint, endPoint);
controlLine.Line = line;
controlLine.Color = color;
isCreate = controlLine.Insert();
}
catch (Exception ex)
{
ErrorDialog.Show(ex, ErrorDialog.Severity.ERROR);
}
finally
{
new TSM.Model().CommitChanges();
}
return isCreate;
}
/// <summary>
/// 참고객체 평면 생성
/// <para>
/// ControlPlane 클래스는 모델링 작업을 돕는 사용자 정의 (가능하면 자기) 평면을 정의합니다.
/// </para>
/// </summary>
/// <param name="origin"></param>
/// <param name="axisX"></param>
/// <param name="axisY"></param>
/// <returns>ControlPlane Insert Result</returns>
public static bool CreateControlPlane(TSG.Point origin, TSG.Vector axisX, TSG.Vector axisY)
{
bool isCreate = false;
TSM.Plane plane = new TSM.Plane();
try
{
plane.Origin = origin;
plane.AxisX = axisX;
plane.AxisY = axisY;
TSM.ControlPlane controlPlane = new TSM.ControlPlane(plane, true);
isCreate = controlPlane.Insert();
}
catch (Exception ex)
{
ErrorDialog.Show(ex, ErrorDialog.Severity.ERROR);
}
finally
{
new TSM.Model().CommitChanges();
}
return isCreate;
}
/// <summary>
/// 참고객체 원 생성
/// <para>
/// ControlCircle 클래스는 모델링 작업을 돕는 사용자 정의 (자성이 아닌) 원을 정의합니다.
/// 중복 된 입력 지점이 있거나 3 개의 입력 지점이 한 줄에 있으면 ControlCircle.Insert ()는 false를 반환합니다.
/// ControlCircle.Select ()는 원의 중심점을 Point1로 되돌립니다.
/// </para>
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <param name="p3"></param>
/// <param name="color"></param>
/// <returns>ControlCircle Insert Result</returns>
public static bool CreateControlCircle(TSG.Point p1, TSG.Point p2, TSG.Point p3, TSM.ControlCircle.ControlCircleColorEnum color)
{
bool isCreate = false;
try
{
TSM.ControlCircle controlCircle = new TSM.ControlCircle(p1, p2, p3);
controlCircle.Color = color;
isCreate = controlCircle.Insert();
}
catch (Exception ex)
{
ErrorDialog.Show(ex, ErrorDialog.Severity.ERROR);
}
finally
{
new TSM.Model().CommitChanges();
}
return isCreate;
}
}
}
|
9a73ae95116343d205bab49890e91b450a83347e
|
C#
|
GMZRD71/Azure4Kinect_Base_4AILab
|
/Kinect Camera Test V 3.5/Assets/camMouseLook.cs
| 2.890625
| 3
|
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
// CLASS - camMouseLook
public class camMouseLook : MonoBehaviour
{
// This keeps track of how movement the camera has made
// since the last update; we need to keep track of the
// total movement so we can add it to the controller
Vector2 mouseLook;
Vector2 smoothV; // This helps smooth out the mouse movement
public float sensitivity = 5.0f; // Mouse sensitivity
public float smoothing = 2.0f; // How much movement we want
GameObject character; // This points back to the camera
// Start is called before the first frame update
void Start()
{
character = this.transform.parent.gameObject; // The parent in this case is the camera
}
// Update is called once per frame
void Update()
{
// Allows control by getting the movement of the mouse
// md = "mouse delta"
// Then multiply the change in mouse movement (delta) by the smoothing and
// sensitivity values
var md = new Vector2(Input.GetAxisRaw("Mouse X"), Input.GetAxisRaw("Mouse Y"));
md = Vector2.Scale(md, new Vector2(sensitivity * smoothing, sensitivity * smoothing));
smoothV.x = Mathf.Lerp(smoothV.x, md.x, 1f / smoothing) ; // Slows it down and Lerps = Linear Interpolation of Movement
smoothV.y = Mathf.Lerp(smoothV.y, md.y, 1f / smoothing) ; // Lerp is very useful when moving between one point and another smoothly
mouseLook += smoothV; // rather than "snapping" from point to point
// Adding operator of all the operations
// Add the mouse look y as a local rotation to the camera along its right axis
// the "-" is an inverted system
// rotation about the y-axis with mouse UP-DOWN
transform.localRotation = Quaternion.AngleAxis(-mouseLook.y, Vector3.right);
// Rotate about the character's upward movement, not the camera, because we want the whole
// character to move - MOUSE SIDE-SIDE
character.transform.localRotation = Quaternion.AngleAxis(mouseLook.x, character.transform.up);
}
}
|
bf792ee92616e0d0b11a6a55efd5cb00240902ec
|
C#
|
DKatsarski/Homework
|
/CSharp/01. CSharp1/1. Intorudcion/Laboratory/Program.cs
| 3.453125
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Intorudcion
{
class HelloCSharp
{
static void Main(string[] args)
{
Console.Write("Please, enter your first name: ");
string a = Console.ReadLine();
Console.Write("Please enter your second name: ");
string b = Console.ReadLine();
Console.Write("Please, enter your age: ");
int age = int.Parse(Console.ReadLine());
//Console.WriteLine("Yes, you are homosexual!");
Console.WriteLine("Hello, {0} {1}!", a, b);
Console.WriteLine("Your age is {0}", age);
Console.WriteLine();
}
}
}
|
cf963ee0c42e62bc2cd1334e0f8a51842d62df05
|
C#
|
FishTheCrusader/mongoose
|
/code/businessentities/collections/PollingPlaceCollection.cs
| 3.03125
| 3
|
using System.Data.Common;
using System.Collections.ObjectModel;
using noi.votinginfoproject.interfaces;
namespace noi.votinginfoproject.businessentities
{
/// <summary>
///
/// </summary>
public class PollingPlaceCollection : Collection<PollingPlace>, ICreateable
{
/// <summary>
/// Populates itself with a database data reader.
/// </summary>
/// <param name="oDataReader">Data reader that holds the elements to populate itself with. Uses the abstract class <see cref="DbDataReader"/> to work with data readers for different DBMSs.</param>
public void Create(DbDataReader oDataReader)
{
PollingPlace oPollingPlace;
if (oDataReader.HasRows)
{
while (oDataReader.Read())
{
oPollingPlace = new PollingPlace();
oPollingPlace.Create(oDataReader);
this.Add(oPollingPlace);
}
}
}
}
}
|
774d4a31f53525b9e246fb987353bb1f69ad3436
|
C#
|
guzlewski/Minesweeper
|
/Minesweeper.Common/Extensions/NetworkStreamExtensions.cs
| 3.15625
| 3
|
using System;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
namespace Minesweeper.Common.Extensions
{
public static class NetworkStreamExtensions
{
private const int headerSize = sizeof(int);
public static async Task SendAsync<T>(this NetworkStream stream, T message, CancellationToken cancellationToken = default)
{
var body = message.Serialize();
var header = BitConverter.GetBytes(body.Length);
await stream.WriteAsync(header, 0, headerSize, cancellationToken).ConfigureAwait(false);
await stream.WriteAsync(body, 0, body.Length, cancellationToken).ConfigureAwait(false);
}
public static async Task<T> ReceiveAsync<T>(this NetworkStream stream, CancellationToken cancellationToken = default)
{
var header = await stream.ReadExactlyNBytesAsync(headerSize, cancellationToken).ConfigureAwait(false);
var bodySize = BitConverter.ToInt32(header, 0);
var body = await stream.ReadExactlyNBytesAsync(bodySize, cancellationToken).ConfigureAwait(false);
return body.Deserialize<T>();
}
private static async Task<byte[]> ReadExactlyNBytesAsync(this NetworkStream stream, int n, CancellationToken cancellationToken)
{
if (n < 1)
{
throw new ArgumentException("Number of bytes to read must be greather than 0", nameof(n));
}
var bytes = new byte[n];
var bytesRead = 0;
while (bytesRead != n)
{
var currentBytes = await stream.ReadAsync(bytes, bytesRead, n - bytesRead, cancellationToken).ConfigureAwait(false);
if (currentBytes == 0)
{
throw new InvalidOperationException("Comunnication closed.");
}
bytesRead += currentBytes;
}
return bytes;
}
}
}
|
4cb7b9aa0b65c47977b194e96e6788564bb01eb3
|
C#
|
Watch-Later/PCLMock
|
/Src/PCLMock/It.cs
| 3.421875
| 3
|
namespace PCLMock
{
using System;
using System.Text.RegularExpressions;
using PCLMock.ArgumentFilters;
/// <summary>
/// Facilitates the filtering of arguments when interacting with mocks.
/// </summary>
/// <remarks>
/// <para>
/// This class provides a number of methods that can be used to filter arguments in calls to <see cref="MockBase{T}.When"/> or <see cref="MockBase{T}.Verify"/>.
/// Consider the following example:
/// </para>
/// <para>
/// <example>
/// <code>
/// <![CDATA[
/// someMock
/// .When(x => x.SomeMethod("abc", It.IsAny<int>(), It.IsNotNull()))
/// .Return(50);
/// ]]>
/// </code>
/// </example>
/// </para>
/// <para>
/// In this case, the specification will only match if the first argument to <c>SomeMethod</c> is <c>"abc"</c> and the third argument is not <see langword="null"/>.
/// The second argument can be anything.
/// </para>
/// <para>
/// Note that the implementation of all <c>public</c> methods is simply to return a default instance of <c>T</c>. The actual implementation is resolved and applied
/// at run-time.
/// </para>
/// </remarks>
public static class It
{
/// <summary>
/// Specifies that any object of type <typeparamref name="T"/> is valid.
/// </summary>
/// <typeparam name="T">
/// The type of object.
/// </typeparam>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsAny<T>() =>
default;
/// <summary>
/// Specifies that only values that equate to <paramref name="expected"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the expected value.
/// </typeparam>
/// <param name="expected">
/// The expected value.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T Is<T>(T expected) =>
default;
/// <summary>
/// Specifies that only values that do not equate to <paramref name="notExpected"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the unexpected value.
/// </typeparam>
/// <param name="notExpected">
/// The value that is not expected.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsNot<T>(T notExpected) =>
default;
/// <summary>
/// Specifies that only values between <paramref name="first"/> and <paramref name="second"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the value.
/// </typeparam>
/// <param name="first">
/// An inclusive value representing one end of the range of values accepted.
/// </param>
/// <param name="second">
/// An inclusive value representing the other end of the range of values accepted.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsBetween<T>(T first, T second)
where T : IComparable<T> =>
default;
/// <summary>
/// Specifies that only values not between <paramref name="first"/> and <paramref name="second"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the value.
/// </typeparam>
/// <param name="first">
/// An inclusive value representing one end of the range of values not accepted.
/// </param>
/// <param name="second">
/// An inclusive value representing the other end of the range of values not accepted.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsNotBetween<T>(T first, T second)
where T : IComparable<T> =>
default;
/// <summary>
/// Specifies that only values greater than <paramref name="value"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the value.
/// </typeparam>
/// <param name="value">
/// The exclusive minimum expected value.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsGreaterThan<T>(T value)
where T : IComparable<T> =>
default;
/// <summary>
/// Specifies that only values less than <paramref name="value"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the value.
/// </typeparam>
/// <param name="value">
/// The exclusive maximum expected value.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsLessThan<T>(T value)
where T : IComparable<T> =>
default;
/// <summary>
/// Specifies that only values greater than or equal to <paramref name="value"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the value.
/// </typeparam>
/// <param name="value">
/// The inclusive minimum expected value.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsGreaterThanOrEqualTo<T>(T value)
where T : IComparable<T> =>
default;
/// <summary>
/// Specifies that only values less than or equal to <paramref name="value"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the value.
/// </typeparam>
/// <param name="value">
/// The inclusive maximum expected value.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsLessThanOrEqualTo<T>(T value)
where T : IComparable<T> =>
default;
/// <summary>
/// Specifies that only values that are within <paramref name="expected"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the expected value.
/// </typeparam>
/// <param name="expected">
/// The set of expected values.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsIn<T>(params T[] expected) =>
default;
/// <summary>
/// Specifies that only values that are like <paramref name="pattern"/> (a regular expression) are to be accepted.
/// </summary>
/// <param name="pattern">
/// The regular expression pattern used to match values.
/// </param>
/// <returns>
/// <see langword="null"/>.
/// </returns>
public static string IsLike(string pattern) =>
default;
/// <summary>
/// Specifies that only values that are like <paramref name="pattern"/> (a regular expression) are to be accepted.
/// </summary>
/// <param name="pattern">
/// The regular expression pattern used to match values.
/// </param>
/// <param name="options">
/// Optional options for the regular expression used when matching.
/// </param>
/// <returns>
/// <see langword="null"/>.
/// </returns>
public static string IsLike(string pattern, RegexOptions options = RegexOptions.None) =>
default;
/// <summary>
/// Specifies that only values that are not like <paramref name="pattern"/> (a regular expression) are to be accepted.
/// </summary>
/// <param name="pattern">
/// The regular expression pattern used to match values.
/// </param>
/// <returns>
/// <see langword="null"/>.
/// </returns>
public static string IsNotLike(string pattern) =>
default;
/// <summary>
/// Specifies that only values that are not like <paramref name="pattern"/> (a regular expression) are to be accepted.
/// </summary>
/// <param name="pattern">
/// The regular expression pattern used to match values.
/// </param>
/// <param name="options">
/// Optional options for the regular expression used when matching.
/// </param>
/// <returns>
/// <see langword="null"/>.
/// </returns>
public static string IsNotLike(string pattern, RegexOptions options = RegexOptions.None) =>
default;
/// <summary>
/// Specifies that only <see langword="null"/> values are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the expected value.
/// </typeparam>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsNull<T>()
where T : class =>
default;
/// <summary>
/// Specifies that only non-<see langword="null"/> values are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the expected value.
/// </typeparam>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsNotNull<T>()
where T : class =>
default;
/// <summary>
/// Specifies that only values of type <typeparamref name="T"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The expected type.
/// </typeparam>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsOfType<T>() =>
default;
/// <summary>
/// Specifies that only values not of type <typeparamref name="T"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The unexpected type.
/// </typeparam>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T IsNotOfType<T>() =>
default;
/// <summary>
/// Specifies that only values for which the given predicate returns <see langword="true"/> are to be accepted.
/// </summary>
/// <typeparam name="T">
/// The type of the expected value.
/// </typeparam>
/// <param name="predicate">
/// The predicate that will be invoked to check the value.
/// </param>
/// <returns>
/// A default instance of type <c>T</c>.
/// </returns>
public static T Matches<T>(Func<T, bool> predicate) =>
default;
// the internal methods below must:
// 1. have the same name as their public counterpart above, but with a "Filter" suffix
// 2. return an implementation of IArgumentFilter that encapsulates the logic for the filter
internal static IArgumentFilter IsAnyFilter<T>() =>
IsAnyArgumentFilter<T>.Instance;
internal static IArgumentFilter IsFilter<T>(T expected) =>
new IsArgumentFilter(expected);
internal static IArgumentFilter IsNotFilter<T>(T notExpected) =>
new LogicalNotArgumentFilter(new IsArgumentFilter(notExpected));
internal static IArgumentFilter IsBetweenFilter<T>(T first, T second)
where T : IComparable<T> =>
new IsBetweenArgumentFilter<T>(first, second);
internal static IArgumentFilter IsNotBetweenFilter<T>(T first, T second)
where T : IComparable<T> =>
new LogicalNotArgumentFilter(new IsBetweenArgumentFilter<T>(first, second));
internal static IArgumentFilter IsGreaterThanFilter<T>(T value)
where T : IComparable<T> =>
new IsGreaterThanArgumentFilter<T>(value);
internal static IArgumentFilter IsLessThanFilter<T>(T value)
where T : IComparable<T> =>
new LogicalNotArgumentFilter(new IsGreaterThanOrEqualToArgumentFilter<T>(value));
internal static IArgumentFilter IsGreaterThanOrEqualToFilter<T>(T value)
where T : IComparable<T> =>
new IsGreaterThanOrEqualToArgumentFilter<T>(value);
internal static IArgumentFilter IsLessThanOrEqualToFilter<T>(T value)
where T : IComparable<T> =>
new LogicalNotArgumentFilter(new IsGreaterThanArgumentFilter<T>(value));
internal static IArgumentFilter IsInFilter<T>(params T[] expected) =>
new IsInArgumentFilter<T>(expected);
internal static IArgumentFilter IsLikeFilter(string pattern)
{
if (pattern == null)
{
throw new ArgumentNullException("pattern");
}
return new IsLikeArgumentFilter(pattern, RegexOptions.None);
}
internal static IArgumentFilter IsLikeFilter(string pattern, RegexOptions options)
{
if (pattern == null)
{
throw new ArgumentNullException("pattern");
}
return new IsLikeArgumentFilter(pattern, options);
}
internal static IArgumentFilter IsNotLikeFilter(string pattern)
{
if (pattern == null)
{
throw new ArgumentNullException("pattern");
}
return new LogicalNotArgumentFilter(new IsLikeArgumentFilter(pattern, RegexOptions.None));
}
internal static IArgumentFilter IsNotLikeFilter(string pattern, RegexOptions options)
{
if (pattern == null)
{
throw new ArgumentNullException("pattern");
}
return new LogicalNotArgumentFilter(new IsLikeArgumentFilter(pattern, options));
}
internal static IArgumentFilter IsNullFilter<T>()
where T : class =>
IsNullArgumentFilter<T>.Instance;
internal static IArgumentFilter IsNotNullFilter<T>()
where T : class =>
new LogicalNotArgumentFilter(IsNullArgumentFilter<T>.Instance);
internal static IArgumentFilter IsOfTypeFilter<T>() =>
IsOfTypeArgumentFilter<T>.Instance;
internal static IArgumentFilter IsNotOfTypeFilter<T>() =>
new LogicalNotArgumentFilter(IsOfTypeArgumentFilter<T>.Instance);
internal static IArgumentFilter MatchesFilter<T>(Func<T, bool> predicate)
{
if (predicate == null)
{
throw new ArgumentNullException("predicate");
}
return new MatchesArgumentFilter<T>(predicate);
}
}
}
|
31cdd06fff6af60c739ef88aa52d36bcf0c0d9e7
|
C#
|
cnechifor/EtmilanAutomation
|
/EtmilanAutomation/CoreFramework/Utils/XMLDataManagement.cs
| 2.71875
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Xml;
namespace EtmilanAutomation.CoreFramework.Utils
{
public class XMLDataManagement
{
private XmlDocument xmlDoc;
private String str1;
public XMLDataManagement(String str)
{
xmlDoc = new XmlDocument();
xmlDoc.LoadXml(WebUtility.HtmlDecode(str));
//xmlDoc.LoadXml(str);
//XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
// nsmgr.AddNamespace("ab", "http://schemas.xmlsoap.org/soap/envelope/");
}
public void ModifyNode(String tag, String value)
{
xmlDoc.GetElementsByTagName(tag)[0].InnerText = value;
}
public void ModifyNode(String tag, int value)
{
xmlDoc.GetElementsByTagName(tag)[0].InnerText = value.ToString();
}
public void ModifyAttribute(String path, String valueAttr)
{
XmlAttribute formId = (XmlAttribute)xmlDoc.SelectSingleNode(path);
if (formId != null)
{
formId.Value = valueAttr; // Set to new value.
}
}
public String GetNodeValue(String node)
{
return xmlDoc.GetElementsByTagName(node)[0].InnerText;
}
public String Output()
{
return xmlDoc.OuterXml;
}
}
}
|
c52bf82c57eab2c4f5614524d16112678a1b1953
|
C#
|
shendongnian/download4
|
/first_version_download2/364020-31213847-94295323-2.cs
| 2.765625
| 3
|
private List<Socket> samp = new List<Socket>();
private void button1_Click(object sender, EventArgs e)
{
//If you don't want the error
//if(samp.Count > 0) return;
IPHostEntry host = null;
Socket sock;
host = Dns.GetHostEntry(entered_ip);
foreach (IPAddress address in host.AddressList)
{
IPEndPoint ipe = new IPEndPoint(address, 7779);
sock = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
sock.Connect(ipe);
if (sock.Connected)
{
enable_anticheat();
samp.Add(sock);
Process.Start("samp://" + entered_ip + ":" + entered_port);
break;
} //The else continue is unnecessary.
}
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
if(samp.Count > 0) {
foreach(Socket s: samp) {
s.close();
}
}
}
|
615b305bc09dd464cd654a2ed769300544a27bd0
|
C#
|
42Spikes/F2S
|
/F2S.MvvmX.Glass.LiveCardDemo.Plugins.Compass.Core/Model/Landmarks.cs
| 2.734375
| 3
|
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using F2S.MvvmX.Glass.LiveCardDemo.Plugins.Compass.Core.Util;
using Newtonsoft.Json;
namespace F2S.MvvmX.Glass.LiveCardDemo.Plugins.Compass.Core.Model
{
public class Landmarks
{
public List<Place> Places { get; set; }
private const double _maxDistanceKM = 10.0;
public Landmarks(string landmarksAsJSON)
{
Places = new List<Place>();
// read a list of places
populatePlaceList(landmarksAsJSON);
}
private void populatePlaceList(string json)
{
var places = JsonConvert.DeserializeObject<List<Place>>(json);
Places = places;
}
internal List<Place> getNearbyLandmarks(double latitude, double longitude)
{
var nearby =
Places.Where(
p => MathUtils.getDistance(
latitude, longitude,
p.Latitiude, p.Longitude) < _maxDistanceKM)
.ToList();
return nearby;
}
}
}
|
f101bbdaa710748434f289b1ee2a043f8651186e
|
C#
|
joaohiago01/space-shooter
|
/Assets/Scripts/EnemyGenerator.cs
| 2.5625
| 3
|
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class EnemyGenerator : MonoBehaviour {
//
public Enemy enemy;
public float timeCreate;
public bool canCreate = true;
void Update() {
if (canCreate == true){
canCreate = false;
StartCoroutine(createEnemy());
}
}
IEnumerator createEnemy() {
yield return new WaitForSeconds(timeCreate);
canCreate = true;
float randomRange = Random.Range(-10, 10);
float speed = Random.Range(0.1f, 0.05f);
Enemy enemyCreate = Instantiate(enemy.gameObject, transform.position + new Vector3(randomRange, 0, 0), transform.rotation).GetComponent<Enemy>();
enemyCreate.speed = speed;
}
}
|
b225ae1115bf87e5c01fe8c40f7db755ee485983
|
C#
|
avmgan/Alchemy4Tridion
|
/Alchemy4Tridion.Plugins/Clients/AlchemyCoreServiceClient201603.cs
| 2.546875
| 3
|
using Alchemy4Tridion.Plugins.Clients.CoreService;
using System;
using System.ServiceModel;
using System.Threading.Tasks;
using System.Xml.Linq;
using Alchemy4Tridion.Plugins.Utilities;
namespace Alchemy4Tridion.Plugins.Clients
{
/// <summary>
/// Provides a wrapper of the Tridion SessionAwareCoreServiceClient using a safe implementation of IDisposable.
/// You can use this client inside of a using statement, and calling its Close or Dispose method will safely
/// close out the
/// </summary>
/// <remarks>
/// Shoutout to Eric Huiza (http://erichuiza.blogspot.com/2013/12/how-to-correctly-dispose-coreservice.html)
/// </remarks>
public class AlchemyCoreServiceClient201603 : IDisposable, IAlchemyCoreServiceClient
{
/// <summary>
/// Whether or not the dispose method has already been called.
/// </summary>
private bool isDisposed = false;
/// <summary>
/// Gets which entpoint was used to create this core service client.
/// </summary>
public SessionAwareCoreServiceEndPoint? ClientEndpoint
{
get;
private set;
}
/// <summary>
/// Gets the name of the user that the client was last impersonated with using the Impersonate method.
/// </summary>
public string ImpersonatedUsername
{
get;
private set;
}
/// <summary>
/// Gets or sets the underlying core service client channel.
/// </summary>
public ISessionAwareCoreService201603 Channel { get; set; }
/// <summary>
/// Creates a new SessionAwareCoreServiceClient using the supplied endpoint.
/// </summary>
/// <param name="endPoint"></param>
public AlchemyCoreServiceClient201603()
{
ClientEndpoint = SessionAwareCoreServiceEndPoint.NetTcp201603;
string endPointConfigName = CoreServiceUtils.GetEndpointConfigurationName(ClientEndpoint ?? SessionAwareCoreServiceEndPoint.NetTcp201603);
var factory = new ChannelFactory<ISessionAwareCoreService201603>(endPointConfigName);
Channel = factory.CreateChannel();
}
/// <summary>
/// Calls the dispose method.
/// </summary>
public void Close()
{
Dispose(true);
}
/// <summary>
/// Implements IDisposable and disposes of the WCF client in a safe manner.
/// </summary>
public void Dispose()
{
Dispose(true);
}
/// <summary>
/// Disposes the client in a safe manner.
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (Channel != null)
{
IClientChannel channel = (IClientChannel)Channel;
if (!this.isDisposed && disposing)
{
this.isDisposed = true;
try
{
if (channel.State != CommunicationState.Closed)
{
channel.Close();
}
}
catch (CommunicationException ex)
{
channel.Abort(); //The channel is aborted and the resources released.
}
catch (TimeoutException ex)
{
channel.Abort(); //The channel is aborted and the resources released.
}
catch (Exception ex)
{
channel.Abort(); // The channel is aborted and the resources released.
}
}
}
}
public UserData Impersonate(string username)
{
ImpersonatedUsername = username;
return Channel.Impersonate(username);
}
public async Task<UserData> ImpersonateAsync(string username)
{
ImpersonatedUsername = username;
return await Task<UserData>.Factory.FromAsync(Channel.BeginImpersonate, Channel.EndImpersonate, username, null);
}
public TridionEnumValue[] GetEnumValues(string type)
{
return Channel.GetEnumValues(type);
}
public async Task<TridionEnumValue[]> GetEnumValuesAsync(string type)
{
return await Task<TridionEnumValue[]>.Factory.FromAsync(Channel.BeginGetEnumValues, Channel.EndGetEnumValues, type, null);
}
public BundleTypeData[] ResolveBundleTypes(string[] itemIds, bool pruneTree)
{
return Channel.ResolveBundleTypes(itemIds, pruneTree);
}
public async Task<BundleTypeData[]> ResolveBundleTypesAsync(string[] itemIds, bool pruneTree)
{
return await Task<BundleTypeData[]>.Factory.FromAsync(Channel.BeginResolveBundleTypes, Channel.EndResolveBundleTypes, itemIds, pruneTree, null);
}
public KeywordData CopyToKeyword(string sourceKeywordId, string destinationId, ReadOptions readBackOptions)
{
return Channel.CopyToKeyword(sourceKeywordId, destinationId, readBackOptions);
}
public async Task<KeywordData> CopyToKeywordAsync(string sourceKeywordId, string destinationId, ReadOptions readBackOptions)
{
return await Task<KeywordData>.Factory.FromAsync(Channel.BeginCopyToKeyword, Channel.EndCopyToKeyword, sourceKeywordId, destinationId, readBackOptions, null);
}
public KeywordData MoveToKeyword(string sourceKeywordId, string destinationId, ReadOptions readBackOptions)
{
return Channel.MoveToKeyword(sourceKeywordId, destinationId, readBackOptions);
}
public async Task<KeywordData> MoveToKeywordAsync(string sourceKeywordId, string destinationId, ReadOptions readBackOptions)
{
return await Task<KeywordData>.Factory.FromAsync(Channel.BeginMoveToKeyword, Channel.EndMoveToKeyword, sourceKeywordId, destinationId, readBackOptions, null);
}
public TridionLanguageInfo[] GetTridionLanguages()
{
return Channel.GetTridionLanguages();
}
public async Task<TridionLanguageInfo[]> GetTridionLanguagesAsync()
{
return await Task<TridionLanguageInfo[]>.Factory.FromAsync(Channel.BeginGetTridionLanguages, Channel.EndGetTridionLanguages, null);
}
public WorkflowScriptType[] GetListWorkflowScriptTypes()
{
return Channel.GetListWorkflowScriptTypes();
}
public async Task<WorkflowScriptType[]> GetListWorkflowScriptTypesAsync()
{
return await Task<WorkflowScriptType[]>.Factory.FromAsync(Channel.BeginGetListWorkflowScriptTypes, Channel.EndGetListWorkflowScriptTypes, null);
}
public WorkItemData[] AddToWorkflow(string[] subjectIds, string activityInstanceId, ReadOptions readBackOptions)
{
return Channel.AddToWorkflow(subjectIds, activityInstanceId, readBackOptions);
}
public async Task<WorkItemData[]> AddToWorkflowAsync(string[] subjectIds, string activityInstanceId, ReadOptions readBackOptions)
{
return await Task<WorkItemData[]>.Factory.FromAsync(Channel.BeginAddToWorkflow, Channel.EndAddToWorkflow, subjectIds, activityInstanceId, readBackOptions, null);
}
public WorkItemData[] RemoveFromWorkflow(string[] subjectIds, ReadOptions readBackOptions)
{
return Channel.RemoveFromWorkflow(subjectIds, readBackOptions);
}
public async Task<WorkItemData[]> RemoveFromWorkflowAsync(string[] subjectIds, ReadOptions readBackOptions)
{
return await Task<WorkItemData[]>.Factory.FromAsync(Channel.BeginRemoveFromWorkflow, Channel.EndRemoveFromWorkflow, subjectIds, readBackOptions, null);
}
public OrganizationalItemData Lock(string organizationalItemId, ReadOptions readBackOptions)
{
return Channel.Lock(organizationalItemId, readBackOptions);
}
public async Task<OrganizationalItemData> LockAsync(string organizationalItemId, ReadOptions readBackOptions)
{
return await Task<OrganizationalItemData>.Factory.FromAsync(Channel.BeginLock, Channel.EndLock, organizationalItemId, readBackOptions, null);
}
public OrganizationalItemData Unlock(string organizationalItemId, ReadOptions readBackOptions)
{
return Channel.Unlock(organizationalItemId, readBackOptions);
}
public async Task<OrganizationalItemData> UnlockAsync(string organizationalItemId, ReadOptions readBackOptions)
{
return await Task<OrganizationalItemData>.Factory.FromAsync(Channel.BeginUnlock, Channel.EndLock, organizationalItemId, readBackOptions, null);
}
public ProcessInstanceData StartWorkflow(string repositoryId, StartWorkflowInstructionData instruction, ReadOptions readBackOptions)
{
return Channel.StartWorkflow(repositoryId, instruction, readBackOptions);
}
public async Task<ProcessInstanceData> StartWorkflowAsync(string repositoryId, StartWorkflowInstructionData instruction, ReadOptions readBackOptions)
{
return await Task<ProcessInstanceData>.Factory.FromAsync(Channel.BeginStartWorkflow, Channel.EndStartWorkflow, repositoryId, instruction, readBackOptions, null);
}
public ProcessDefinitionAssociationDictionary GetProcessDefinitionsForItems(string[] itemIds, ProcessDefinitionType processDefinitionType)
{
return Channel.GetProcessDefinitionsForItems(itemIds, processDefinitionType);
}
public async Task<ProcessDefinitionAssociationDictionary> GetProcessDefinitionsForItemsAsync(string[] itemIds, ProcessDefinitionType processDefinitionType)
{
return await Task<ProcessDefinitionAssociationDictionary>.Factory.FromAsync(Channel.BeginGetProcessDefinitionsForItems, Channel.EndGetProcessDefinitionsForItems, itemIds, processDefinitionType, null);
}
public string GetSystemXsd(string filename)
{
return Channel.GetSystemXsd(filename);
}
public async Task<string> GetSystemXsdAsync(string filename)
{
return await Task<string>.Factory.FromAsync(Channel.BeginGetSystemXsd, Channel.EndGetSystemXsd, filename, null);
}
public LinkToSchemaData[] GetSchemasByNamespaceUri(string repositoryId, string namespaceUri, string rootElementName)
{
return Channel.GetSchemasByNamespaceUri(repositoryId, namespaceUri, rootElementName);
}
public async Task<LinkToSchemaData[]> GetSchemasByNamespaceUriAsync(string repositoryId, string namespaceUri, string rootElementName)
{
return await Task<LinkToSchemaData[]>.Factory.FromAsync(Channel.BeginGetSchemasByNamespaceUri, Channel.EndGetSchemasByNamespaceUri, repositoryId, namespaceUri, rootElementName, null);
}
public ValidationErrorData[] Validate(IdentifiableObjectData deltaData)
{
return Channel.Validate(deltaData);
}
public async Task<ValidationErrorData[]> ValidateAsync(IdentifiableObjectData deltaData)
{
return await Task<ValidationErrorData[]>.Factory.FromAsync(Channel.BeginValidate, Channel.EndValidate, deltaData, null);
}
public BinaryContentData GetExternalBinaryContentData(string uri)
{
return Channel.GetExternalBinaryContentData(uri);
}
public async Task<BinaryContentData> GetExternalBinaryContentDataAsync(string uri)
{
return await Task<BinaryContentData>.Factory.FromAsync(Channel.BeginGetExternalBinaryContentData, Channel.EndGetExternalBinaryContentData, uri, null);
}
public SynchronizationResult SynchronizeWithSchema(IdentifiableObjectData dataObject, SynchronizeOptions synchronizeOptions)
{
return Channel.SynchronizeWithSchema(dataObject, synchronizeOptions);
}
public async Task<SynchronizationResult> SynchronizeWithSchemaAsync(IdentifiableObjectData dataObject, SynchronizeOptions synchronizeOptions)
{
return await Task<SynchronizationResult>.Factory.FromAsync(Channel.BeginSynchronizeWithSchema, Channel.EndSynchronizeWithSchema, dataObject, synchronizeOptions, null);
}
public SynchronizationResult SynchronizeWithSchemaAndUpdate(string itemId, SynchronizeOptions synchronizeOptions)
{
return Channel.SynchronizeWithSchemaAndUpdate(itemId, synchronizeOptions);
}
public async Task<SynchronizationResult> SynchronizeWithSchemaAndUpdateAsync(string itemId, SynchronizeOptions synchronizeOptions)
{
return await Task<SynchronizationResult>.Factory.FromAsync(Channel.BeginSynchronizeWithSchemaAndUpdate, Channel.EndSynchronizeWithSchemaAndUpdate, itemId, synchronizeOptions, null);
}
public void DecommissionPublicationTarget(string publicationTargetId)
{
Channel.DecommissionPublicationTarget(publicationTargetId);
}
public async Task DecommissionPublicationTargetAsync(string publicationTargetId)
{
await Task.Factory.FromAsync(Channel.BeginDecommissionPublicationTarget(publicationTargetId, null, null), Channel.EndDecommissionPublicationTarget);
}
public SchemaFieldsData ConvertXsdToSchemaFields(XElement xsd, SchemaPurpose purpose, string rootElementName, ReadOptions readOptions)
{
return Channel.ConvertXsdToSchemaFields(xsd, purpose, rootElementName, readOptions);
}
public async Task<SchemaFieldsData> ConvertXsdToSchemaFieldsAsync(XElement xsd, SchemaPurpose purpose, string rootElementName, ReadOptions readOptions)
{
return await Task<SchemaFieldsData>.Factory.FromAsync(Channel.BeginConvertXsdToSchemaFields(xsd, purpose, rootElementName, readOptions, null, null), Channel.EndConvertXsdToSchemaFields);
}
public string GetPublishUrl(string id, string targetTypeIdOrPurpose)
{
return Channel.GetPublishUrl(id, targetTypeIdOrPurpose);
}
public async Task<string> GetPublishUrlAsync(string id, string targetTypeIdOrPurpose)
{
return await Task<string>.Factory.FromAsync(Channel.BeginGetPublishUrl, Channel.EndGetPublishUrl, id, targetTypeIdOrPurpose, null);
}
public LinkToBusinessProcessTypeData[] GetBusinessProcessTypes(string cdTopologyTypeId)
{
return Channel.GetBusinessProcessTypes(cdTopologyTypeId);
}
public async Task<LinkToBusinessProcessTypeData[]> GetBusinessProcessTypesAsync(string cdTopologyTypeId)
{
return await Task<LinkToBusinessProcessTypeData[]>.Factory.FromAsync(Channel.BeginGetBusinessProcessTypes, Channel.EndGetBusinessProcessTypes, cdTopologyTypeId, null);
}
public PublishSourceData GetPublishSourceByUrl(string url)
{
return Channel.GetPublishSourceByUrl(url);
}
public async Task<PublishSourceData> GetPublishSourceByUrlAsync(string url)
{
return await Task<PublishSourceData>.Factory.FromAsync(Channel.BeginGetPublishSourceByUrl, Channel.EndGetPublishSourceByUrl, url, null);
}
public void RemovePublishStates(string publicationId, string targetTypeIdOrPurpose)
{
Channel.RemovePublishStates(publicationId, targetTypeIdOrPurpose);
}
public async Task RemovePublishStatesAsync(string publicationId, string targetTypeIdOrPurpose)
{
await Task.Factory.FromAsync(Channel.BeginRemovePublishStates, Channel.EndRemovePublishStates, publicationId, targetTypeIdOrPurpose, null);
}
public ContainingPagesDictionary ResolveContainingPages(string componentId, ResolveContainingPagesInstructionData instruction)
{
return Channel.ResolveContainingPages(componentId, instruction);
}
public async Task<ContainingPagesDictionary> ResolveContainingPagesAsync(string componentId, ResolveContainingPagesInstructionData instruction)
{
return await Task<ContainingPagesDictionary>.Factory.FromAsync(Channel.BeginResolveContainingPages, Channel.EndResolveContainingPages, componentId, instruction, null);
}
public void PurgeWorkflowHistory(PurgeWorkflowHistoryInstructionData instruction)
{
Channel.PurgeWorkflowHistory(instruction);
}
public async Task PurgeWorkflowHistoryAsync(PurgeWorkflowHistoryInstructionData instruction)
{
await Task.Factory.FromAsync(Channel.BeginPurgeWorkflowHistory, Channel.EndPurgeWorkflowHistory, instruction, null);
}
public void BroadcastNotification(NotificationMessage notification)
{
Channel.BroadcastNotification(notification);
}
public async Task BroadcastNotificationAsync(NotificationMessage notification)
{
await Task.Factory.FromAsync(Channel.BeginBroadcastNotification, Channel.EndBroadcastNotification, notification, null);
}
public SystemPrivilege[] GetSystemPrivileges()
{
return Channel.GetSystemPrivileges();
}
public async Task<SystemPrivilege[]> GetSystemPrivilegesAsync()
{
return await Task.Factory.FromAsync(Channel.BeginGetSystemPrivileges, Channel.EndGetSystemPrivileges, null);
}
public string GetApiVersion()
{
return Channel.GetApiVersion();
}
public async Task<string> GetApiVersionAsync()
{
return await Task<string>.Factory.FromAsync(Channel.BeginGetApiVersion, Channel.EndGetApiVersion, null);
}
public AccessTokenData GetCurrentUserWithToken()
{
return Channel.GetCurrentUser();
}
public async Task<AccessTokenData> GetCurrentUserWithTokenAsync()
{
return await Task<AccessTokenData>.Factory.FromAsync(Channel.BeginGetCurrentUser, Channel.EndGetCurrentUser, null);
}
public bool IsExistingObject(string id)
{
return Channel.IsExistingObject(id);
}
public async Task<bool> IsExistingObjectAsync(string id)
{
return await Task<bool>.Factory.FromAsync(Channel.BeginIsExistingObject, Channel.EndIsExistingObject, id, null);
}
public string GetTcmUri(string baseUri, string contextRepositoryUri, uint? version)
{
return Channel.GetTcmUri(baseUri, contextRepositoryUri, version);
}
public async Task<string> GetTcmUriAsync(string baseUri, string contextRepositoryUri, uint? version = null)
{
return await Task<string>.Factory.FromAsync(Channel.BeginGetTcmUri, Channel.EndGetTcmUri, baseUri, contextRepositoryUri, version, null);
}
public string TryGetTcmUri(string baseUri, string contextRepositoryUri, uint? version)
{
return Channel.TryGetTcmUri(baseUri, contextRepositoryUri, version);
}
public async Task<string> TryGetTcmUriAsync(string baseUri, string contextRepositoryUri, uint? version = null)
{
return await Task<string>.Factory.FromAsync(Channel.BeginTryGetTcmUri, Channel.EndTryGetTcmUri, baseUri, contextRepositoryUri, version, null);
}
public IdentifiableObjectData Read(string id)
{
return Channel.Read(id, null);
}
public IdentifiableObjectData Read(string id, ReadOptions readOptions)
{
return Channel.Read(id, readOptions);
}
public async Task<IdentifiableObjectData> ReadAsync(string id, ReadOptions readOptions = null)
{
return await Task<IdentifiableObjectData>.Factory.FromAsync(Channel.BeginRead, Channel.EndRead, id, readOptions, null);
}
public IdentifiableObjectData TryRead(string id, ReadOptions readOptions = null)
{
return Channel.TryRead(id, readOptions);
}
public async Task<IdentifiableObjectData> TryReadAsync(string id, ReadOptions readOptions = null)
{
return await Task<IdentifiableObjectData>.Factory.FromAsync(Channel.BeginTryRead, Channel.EndTryRead, id, readOptions, null);
}
public ItemReadResultDictionary BulkRead(string[] ids, ReadOptions readOptions)
{
return Channel.BulkRead(ids, readOptions);
}
public async Task<ItemReadResultDictionary> BulkReadAsync(string[] ids, ReadOptions readOptions)
{
return await Task<ItemReadResultDictionary>.Factory.FromAsync(Channel.BeginBulkRead, Channel.EndBulkRead, ids, readOptions, null);
}
public SchemaFieldsData ReadSchemaFields(string schemaId, bool expandEmbeddedFields, ReadOptions readOptions)
{
return Channel.ReadSchemaFields(schemaId, expandEmbeddedFields, readOptions);
}
public async Task<SchemaFieldsData> ReadSchemaFieldsAsync(string schemaId, bool expandEmbeddedFields, ReadOptions readOptions = null)
{
return await Task<SchemaFieldsData>.Factory.FromAsync(Channel.BeginReadSchemaFields, Channel.EndReadSchemaFields, schemaId, expandEmbeddedFields, readOptions, null);
}
public XElement ConvertSchemaFieldsToXsd(SchemaFieldsData schemaFieldsData)
{
return Channel.ConvertSchemaFieldsToXsd(schemaFieldsData);
}
public async Task<XElement> ConvertSchemaFieldsToXsdAsync(SchemaFieldsData schemaFieldsData)
{
return await Task<XElement>.Factory.FromAsync(Channel.BeginConvertSchemaFieldsToXsd, Channel.EndConvertSchemaFieldsToXsd, schemaFieldsData, null);
}
public IdentifiableObjectData Save(IdentifiableObjectData deltaData, ReadOptions readBackOptions)
{
return Channel.Save(deltaData, readBackOptions);
}
public async Task<IdentifiableObjectData> SaveAsync(IdentifiableObjectData deltaData, ReadOptions readBackOptions = null)
{
return await Task<IdentifiableObjectData>.Factory.FromAsync(Channel.BeginSave, Channel.EndSave, deltaData, readBackOptions, null);
}
public void Delete(string id)
{
Channel.Delete(id);
}
public async Task DeleteAsync(string id)
{
await Task.Factory.FromAsync(Channel.BeginDelete, Channel.EndDelete, id, null);
}
public void DeleteTaxonomyNode(string id, DeleteTaxonomyNodeMode deleteTaxonomyNodeMode)
{
Channel.DeleteTaxonomyNode(id, deleteTaxonomyNodeMode);
}
public async Task DeleteTaxonomyNodeAsync(string id, DeleteTaxonomyNodeMode deleteTaxonomyNodeMode)
{
await Task.Factory.FromAsync(Channel.BeginDeleteTaxonomyNode, Channel.EndDeleteTaxonomyNode, id, deleteTaxonomyNodeMode, null);
}
public IdentifiableObjectData GetDefaultData(ItemType itemType, string containerId, ReadOptions readOptions)
{
return Channel.GetDefaultData(itemType, containerId, readOptions);
}
public async Task<IdentifiableObjectData> GetDefaultDataAsync(ItemType itemType, string containerId, ReadOptions readOptions = null)
{
return await Task<IdentifiableObjectData>.Factory.FromAsync(Channel.BeginGetDefaultData, Channel.EndGetDefaultData, itemType, containerId, readOptions, null);
}
public RepositoryLocalObjectData Move(string id, string destinationId, ReadOptions readBackOptions)
{
return Channel.Move(id, destinationId, readBackOptions);
}
public async Task<RepositoryLocalObjectData> MoveAsync(string id, string destinationId, ReadOptions readBackOptions = null)
{
return await Task<RepositoryLocalObjectData>.Factory.FromAsync(Channel.BeginMove, Channel.EndMove, id, destinationId, readBackOptions, null);
}
public RepositoryLocalObjectData Copy(string id, string destinationId, bool makeUnique, ReadOptions readBackOptions)
{
return Channel.Copy(id, destinationId, makeUnique, readBackOptions);
}
public async Task<RepositoryLocalObjectData> CopyAsync(string id, string destinationId, bool makeUnique, ReadOptions readBackOptions = null)
{
return await Task<RepositoryLocalObjectData>.Factory.FromAsync(Channel.BeginCopy(id, destinationId, makeUnique, readBackOptions, null, null), Channel.EndCopy);
}
public InstanceData GetInstanceData(string schemaId, string containerItemId, ReadOptions readOptions)
{
return Channel.GetInstanceData(schemaId, containerItemId, readOptions);
}
public async Task<InstanceData> GetInstanceDataAsync(string schemaId, string containerItemId, ReadOptions readOptions = null)
{
return await Task<InstanceData>.Factory.FromAsync(Channel.BeginGetInstanceData, Channel.EndGetInstanceData, schemaId, containerItemId, readOptions, null);
}
public IdentifiableObjectData TryCheckOut(string id, ReadOptions readBackOptions)
{
return Channel.TryCheckOut(id, readBackOptions);
}
public async Task<IdentifiableObjectData> TryCheckOutAsync(string id, ReadOptions readBackOptions = null)
{
return await Task<IdentifiableObjectData>.Factory.FromAsync(Channel.BeginTryCheckOut, Channel.EndTryCheckOut, id, readBackOptions, null);
}
public VersionedItemData CheckOut(string id, bool permanentLock, ReadOptions readBackOptions)
{
return Channel.CheckOut(id, permanentLock, readBackOptions);
}
public async Task<VersionedItemData> CheckOutAsync(string id, bool permanentLock = false, ReadOptions readBackOptions = null)
{
return await Task<VersionedItemData>.Factory.FromAsync(Channel.BeginCheckOut, Channel.EndCheckOut, id, permanentLock, readBackOptions, null);
}
public VersionedItemData CheckIn(string id, bool removePermanentLock, string userComment, ReadOptions readBackOptions)
{
return Channel.CheckIn(id, removePermanentLock, userComment, readBackOptions);
}
public async Task<VersionedItemData> CheckInAsync(string id, bool removePermanentLock, string userComment, ReadOptions readBackOptions = null)
{
return await Task<VersionedItemData>.Factory.FromAsync(Channel.BeginCheckIn(id, removePermanentLock, userComment, readBackOptions, null, null), Channel.EndCheckIn);
}
public IdentifiableObjectData Update(IdentifiableObjectData deltaData, ReadOptions readBackOptions)
{
return Channel.Update(deltaData, readBackOptions);
}
public async Task<IdentifiableObjectData> UpdateAsync(IdentifiableObjectData deltaData, ReadOptions readBackOptions = null)
{
return await Task<IdentifiableObjectData>.Factory.FromAsync(Channel.BeginUpdate, Channel.EndUpdate, deltaData, readBackOptions, null);
}
public IdentifiableObjectData Create(IdentifiableObjectData data, ReadOptions readBackOptions)
{
return Channel.Create(data, readBackOptions);
}
public async Task<IdentifiableObjectData> CreateAsync(IdentifiableObjectData data, ReadOptions readBackOptions = null)
{
return await Task<IdentifiableObjectData>.Factory.FromAsync(Channel.BeginCreate, Channel.EndCreate, data, readBackOptions, null);
}
public VersionedItemData UndoCheckOut(string id, bool permanentLock, ReadOptions readBackOptions)
{
return Channel.UndoCheckOut(id, permanentLock, readBackOptions);
}
public async Task<VersionedItemData> UndoCheckOutAsync(string id, bool permanentLock, ReadOptions readBackOptions = null)
{
return await Task<VersionedItemData>.Factory.FromAsync(Channel.BeginUndoCheckOut, Channel.EndUndoCheckOut, id, permanentLock, readBackOptions, null);
}
public VersionedItemData Rollback(string id, bool deleteVersions, string comment, ReadOptions readBackOptions)
{
return Channel.Rollback(id, deleteVersions, comment, readBackOptions);
}
public async Task<VersionedItemData> RollbackAsync(string id, bool deleteVersions, string comment, ReadOptions readBackOptions = null)
{
return await Task<VersionedItemData>.Factory.FromAsync(Channel.BeginRollback(id, deleteVersions, comment, readBackOptions, null, null), Channel.EndRollback);
}
public RepositoryLocalObjectData Localize(string id, ReadOptions readBackOptions)
{
return Channel.Localize(id, readBackOptions);
}
public async Task<RepositoryLocalObjectData> LocalizeAsync(string id, ReadOptions readBackOptions = null)
{
return await Task<RepositoryLocalObjectData>.Factory.FromAsync(Channel.BeginLocalize, Channel.EndLocalize, id, readBackOptions, null);
}
public RepositoryLocalObjectData UnLocalize(string id, ReadOptions readBackOptions)
{
return Channel.UnLocalize(id, readBackOptions);
}
public async Task<RepositoryLocalObjectData> UnLocalizeAsync(string id, ReadOptions readBackOptions = null)
{
return await Task<RepositoryLocalObjectData>.Factory.FromAsync(Channel.BeginUnLocalize, Channel.EndUnLocalize, id, readBackOptions, null);
}
public OperationResultDataOfRepositoryLocalObjectData Promote(string id, string destinationRepositoryId, OperationInstruction instruction, ReadOptions readBackOptions)
{
return Channel.Promote(id, destinationRepositoryId, instruction, readBackOptions);
}
public async Task<OperationResultDataOfRepositoryLocalObjectData> PromoteAsync(string id, string destinationRepositoryId, OperationInstruction instruction, ReadOptions readBackOptions)
{
return await Task<OperationResultDataOfRepositoryLocalObjectData>.Factory.FromAsync(Channel.BeginPromote(id, destinationRepositoryId, instruction, readBackOptions, null, null), Channel.EndPromote);
}
public OperationResultDataOfRepositoryLocalObjectData Demote(string id, string destinationRepositoryId, OperationInstruction instruction, ReadOptions readBackOptions)
{
return Channel.Demote(id, destinationRepositoryId, instruction, readBackOptions);
}
public async Task<OperationResultDataOfRepositoryLocalObjectData> DemoteAsync(string id, string destinationRepositoryId, OperationInstruction instruction, ReadOptions readBackOptions)
{
return await Task<OperationResultDataOfRepositoryLocalObjectData>.Factory.FromAsync(Channel.BeginDemote(id, destinationRepositoryId, instruction, readBackOptions, null, null), Channel.EndDemote);
}
public TemplateType[] GetListTemplateTypes(ItemType? itemType)
{
return Channel.GetListTemplateTypes(itemType);
}
public async Task<TemplateType[]> GetListTemplateTypesAsync(ItemType? itemType = null)
{
return await Task<TemplateType[]>.Factory.FromAsync(Channel.BeginGetListTemplateTypes, Channel.EndGetListTemplateTypes, itemType, null);
}
public PublicationType[] GetListPublicationTypes()
{
return Channel.GetListPublicationTypes();
}
public async Task<PublicationType[]> GetListPublicationTypesAsync()
{
return await Task<PublicationType[]>.Factory.FromAsync(Channel.BeginGetListPublicationTypes, Channel.EndGetListPublicationTypes, null);
}
public XElement GetSystemWideListXml(SystemWideListFilterData filter)
{
return Channel.GetSystemWideListXml(filter);
}
public async Task<XElement> GetSystemWideListXmlAsync(SystemWideListFilterData filter)
{
return await Task<XElement>.Factory.FromAsync(Channel.BeginGetSystemWideListXml, Channel.EndGetSystemWideListXml, filter, null);
}
public IdentifiableObjectData[] GetSystemWideList(SystemWideListFilterData filter)
{
return Channel.GetSystemWideList(filter);
}
public async Task<IdentifiableObjectData[]> GetSystemWideListAsync(SystemWideListFilterData filter)
{
return await Task<IdentifiableObjectData[]>.Factory.FromAsync(Channel.BeginGetSystemWideList, Channel.EndGetSystemWideList, filter, null);
}
public XElement GetListXml(string id, SubjectRelatedListFilterData filter)
{
return Channel.GetListXml(id, filter);
}
public async Task<XElement> GetListXmlAsync(string id, SubjectRelatedListFilterData filter)
{
return await Task<XElement>.Factory.FromAsync(Channel.BeginGetListXml, Channel.EndGetListXml, id, filter, null);
}
public IdentifiableObjectData[] GetList(string id, SubjectRelatedListFilterData filter)
{
return Channel.GetList(id, filter);
}
public async Task<IdentifiableObjectData[]> GetListAsync(string id, SubjectRelatedListFilterData filter)
{
return await Task<IdentifiableObjectData[]>.Factory.FromAsync(Channel.BeginGetList, Channel.EndGetList, id, filter, null);
}
public string[] GetListDirectoryServiceNames()
{
return Channel.GetListDirectoryServiceNames();
}
public async Task<string[]> GetListDirectoryServiceNamesAsync()
{
return await Task<string[]>.Factory.FromAsync(Channel.BeginGetListDirectoryServiceNames, Channel.EndGetListDirectoryServiceNames, null);
}
public WindowsUser[] GetListWindowsDomainUsers(string domainName)
{
return Channel.GetListWindowsDomainUsers(domainName);
}
public async Task<WindowsUser[]> GetListWindowsDomainUsersAsync(string domainName)
{
return await Task<WindowsUser[]>.Factory.FromAsync(Channel.BeginGetListWindowsDomainUsers, Channel.EndGetListWindowsDomainUsers, domainName, null);
}
public DirectoryServiceUser[] GetListDirectoryServiceAllUsers(string directoryServiceName)
{
return Channel.GetListDirectoryServiceAllUsers(directoryServiceName);
}
public async Task<DirectoryServiceUser[]> GetListDirectoryServiceAllUsersAsync(string directoryServiceName)
{
return await Task<DirectoryServiceUser[]>.Factory.FromAsync(Channel.BeginGetListDirectoryServiceAllUsers, Channel.EndGetListDirectoryServiceAllUsers, directoryServiceName, null);
}
public DirectoryServiceUser[] GetListDirectoryServiceGroupMembers(string directoryServiceName, string groupDN)
{
return Channel.GetListDirectoryServiceGroupMembers(directoryServiceName, groupDN);
}
public async Task<DirectoryServiceUser[]> GetListDirectoryServiceGroupMembersAsync(string directoryServiceName, string groupDN)
{
return await Task<DirectoryServiceUser[]>.Factory.FromAsync(Channel.BeginGetListDirectoryServiceGroupMembers, Channel.EndGetListDirectoryServiceGroupMembers, directoryServiceName, groupDN, null);
}
public DirectoryServiceUser[] GetListDirectoryServiceUsers(string directoryServiceName, DirectoryUsersFilter filter)
{
return Channel.GetListDirectoryServiceUsers(directoryServiceName, filter);
}
public async Task<DirectoryServiceUser[]> GetListDirectoryServiceUsersAsync(string directoryServiceName, DirectoryUsersFilter filter)
{
return await Task<DirectoryServiceUser[]>.Factory.FromAsync(Channel.BeginGetListDirectoryServiceUsers, Channel.EndGetListDirectoryServiceUsers, directoryServiceName, filter, null);
}
public ClassificationInfoData Classify(string id, string[] keywordIds, ReadOptions readOptions)
{
return Channel.Classify(id, keywordIds, readOptions);
}
public async Task<ClassificationInfoData> ClassifyAsync(string id, string[] keywordIds, ReadOptions readOptions = null)
{
return await Task<ClassificationInfoData>.Factory.FromAsync(Channel.BeginClassify, Channel.EndClassify, id, keywordIds, readOptions, null);
}
public ClassificationInfoData UnClassify(string id, string[] keywordIds, ReadOptions readOptions)
{
return Channel.UnClassify(id, keywordIds, readOptions);
}
public async Task<ClassificationInfoData> UnClassifyAsync(string id, string[] keywordIds, ReadOptions readOptions = null)
{
return await Task<ClassificationInfoData>.Factory.FromAsync(Channel.BeginUnClassify, Channel.EndUnClassify, id, keywordIds, readOptions, null);
}
public ClassificationInfoData ReClassify(string id, string[] keywordIdsToRemove, string[] keywordIdsToAdd, ReadOptions readOptions)
{
return Channel.ReClassify(id, keywordIdsToRemove, keywordIdsToAdd, readOptions);
}
public async Task<ClassificationInfoData> ReClassifyAsync(string id, string[] keywordIdsToRemove, string[] keywordIdsToAdd, ReadOptions readOptions)
{
return await Task<ClassificationInfoData>.Factory.FromAsync(Channel.BeginReClassify(id, keywordIdsToRemove, keywordIdsToAdd, readOptions, null, null), Channel.EndReClassify);
}
public ActivityInstanceData StartActivity(string activityInstanceId, ReadOptions readBackOptions)
{
return Channel.StartActivity(activityInstanceId, readBackOptions);
}
public async Task<ActivityInstanceData> StartActivityAsync(string activityInstanceId, ReadOptions readBackOptions = null)
{
return await Task<ActivityInstanceData>.Factory.FromAsync(Channel.BeginStartActivity, Channel.EndStartActivity, activityInstanceId, readBackOptions, null);
}
public ActivityInstanceData SuspendActivity(string activityInstanceId, string reason, DateTime? resumeAt, string resumeBookmark, ReadOptions readBackOptions)
{
return Channel.SuspendActivity(activityInstanceId, reason, resumeAt, resumeBookmark, readBackOptions);
}
public async Task<ActivityInstanceData> SuspendActivityAsync(string activityInstanceId, string reason, DateTime? resumeAt, string resumeBookmark, ReadOptions readBackOptions)
{
return await Task<ActivityInstanceData>.Factory.FromAsync(Channel.BeginSuspendActivity(activityInstanceId, reason, resumeAt, resumeBookmark, readBackOptions, null, null), Channel.EndSuspendActivity);
}
public ActivityInstanceData RestartActivity(string activityInstanceId, ReadOptions readBackOptions)
{
return Channel.RestartActivity(activityInstanceId, readBackOptions);
}
public async Task<ActivityInstanceData> RestartActivityAsync(string activityInstanceId, ReadOptions readBackOptions)
{
return await Task<ActivityInstanceData>.Factory.FromAsync(Channel.BeginRestartActivity, Channel.EndRestartActivity, activityInstanceId, readBackOptions, null);
}
public ActivityInstanceData ReAssignActivity(string activityInstanceId, string newAssigneeId, ReadOptions readBackOptions)
{
return Channel.ReAssignActivity(activityInstanceId, newAssigneeId, readBackOptions);
}
public async Task<ActivityInstanceData> ReAssignActivityAsync(string activityInstanceId, string newAssigneeId, ReadOptions readBackOptions)
{
return await Task<ActivityInstanceData>.Factory.FromAsync(Channel.BeginReAssignActivity, Channel.EndReAssignActivity, activityInstanceId, newAssigneeId, readBackOptions, null);
}
public ActivityInstanceData FinishActivity(string activityInstanceId, ActivityFinishData activityFinishData, ReadOptions readOptions)
{
return Channel.FinishActivity(activityInstanceId, activityFinishData, readOptions);
}
public async Task<ActivityInstanceData> FinishActivityAsync(string activityInstanceId, ActivityFinishData activityFinishData, ReadOptions readOptions)
{
return await Task<ActivityInstanceData>.Factory.FromAsync(Channel.BeginFinishActivity, Channel.EndFinishActivity, activityInstanceId, activityFinishData, readOptions, null);
}
public ProcessHistoryData ForceFinishProcess(string processInstanceId, string approvalStatusId, ReadOptions readOptions)
{
return Channel.ForceFinishProcess(processInstanceId, approvalStatusId, readOptions);
}
public async Task<ProcessHistoryData> ForceFinishProcessAsync(string processInstanceId, string approvalStatusId, ReadOptions readOptions)
{
return await Task<ProcessHistoryData>.Factory.FromAsync(Channel.BeginForceFinishProcess, Channel.EndForceFinishProcess, processInstanceId, approvalStatusId, readOptions, null);
}
public ActivityInstanceData ResumeActivity(string activityInstanceId, ReadOptions readOptions)
{
return Channel.ResumeActivity(activityInstanceId, readOptions);
}
public async Task<ActivityInstanceData> ResumeActivityAsync(string activityInstanceId, ReadOptions readOptions)
{
return await Task.Factory.FromAsync(Channel.BeginResumeActivity, Channel.EndResumeActivity, activityInstanceId, readOptions, null);
}
public QueueMessageData[] GetListQueueMessages(int queueId)
{
return Channel.GetListQueueMessages(queueId);
}
public async Task<QueueMessageData[]> GetListQueueMessagesAsync(int queueId)
{
return await Task<QueueMessageData[]>.Factory.FromAsync(Channel.BeginGetListQueueMessages, Channel.EndGetListQueueMessages, queueId, null);
}
public void PurgeQueue(int queueId)
{
Channel.PurgeQueue(queueId);
}
public async Task PurgeQueueAsync(int queueId)
{
await Task.Factory.FromAsync(Channel.BeginPurgeQueue, Channel.EndPurgeQueue, queueId, null);
}
public QueueData[] GetListQueues()
{
return Channel.GetListQueues();
}
public async Task<QueueData[]> GetListQueuesAsync()
{
return await Task<QueueData[]>.Factory.FromAsync(Channel.BeginGetListQueues, Channel.EndGetListQueues, null);
}
public ApplicationData ReadApplicationData(string subjectId, string applicationId)
{
return Channel.ReadApplicationData(subjectId, applicationId);
}
public async Task<ApplicationData> ReadApplicationDataAsync(string subjectId, string applicationId)
{
return await Task<ApplicationData>.Factory.FromAsync(Channel.BeginReadApplicationData, Channel.EndReadApplicationData, subjectId, applicationId, null);
}
public ApplicationData[] ReadAllApplicationData(string subjectId)
{
return Channel.ReadAllApplicationData(subjectId);
}
public async Task<ApplicationData[]> ReadAllApplicationDataAsync(string subjectId)
{
return await Task<ApplicationData[]>.Factory.FromAsync(Channel.BeginReadAllApplicationData, Channel.EndReadAllApplicationData, subjectId, null);
}
public void SaveApplicationData(string subjectId, ApplicationData[] applicationData)
{
Channel.SaveApplicationData(subjectId, applicationData);
}
public async Task SaveApplicationDataAsync(string subjectId, ApplicationData[] applicationData)
{
await Task.Factory.FromAsync(Channel.BeginSaveApplicationData, Channel.EndSaveApplicationData, subjectId, applicationData, null);
}
public void DeleteApplicationData(string subjectId, string applicationId)
{
Channel.DeleteApplicationData(subjectId, applicationId);
}
public async Task DeleteApplicationDataAsync(string subjectId, string applicationId)
{
await Task.Factory.FromAsync(Channel.BeginDeleteApplicationData, Channel.EndDeleteApplicationData, subjectId, applicationId, null);
}
public string[] GetApplicationIds()
{
return Channel.GetApplicationIds();
}
public async Task<string[]> GetApplicationIdsAsync()
{
return await Task<string[]>.Factory.FromAsync(Channel.BeginGetApplicationIds, Channel.EndGetApplicationIds, null);
}
public void PurgeApplicationData(string applicationId)
{
Channel.PurgeApplicationData(applicationId);
}
public async Task PurgeApplicationDataAsync(string applicationId)
{
await Task.Factory.FromAsync(Channel.BeginPurgeApplicationData, Channel.EndPurgeApplicationData, applicationId, null);
}
public PredefinedBatchOperation? ParsePredefinedBatchOperation(string operation)
{
return Channel.ParsePredefinedBatchOperation(operation);
}
public async Task<PredefinedBatchOperation?> ParsePredefinedBatchOperationAsync(string operation)
{
return await Task<PredefinedBatchOperation?>.Factory.FromAsync(Channel.BeginParsePredefinedBatchOperation, Channel.EndParsePredefinedBatchOperation, operation, null);
}
public string GetPredefinedBatchOperationName(PredefinedBatchOperation operation)
{
return Channel.GetPredefinedBatchOperationName(operation);
}
public async Task<string> GetPredefinedBatchOperationNameAsync(PredefinedBatchOperation operation)
{
return await Task<string>.Factory.FromAsync(Channel.BeginGetPredefinedBatchOperationName, Channel.EndGetPredefinedBatchOperationName, operation, null);
}
public PublishContextData[] ResolveItems(string[] ids, ResolveInstructionData resolveInstruction, string[] targetIdsOrPurposes, ReadOptions readOptions)
{
return Channel.ResolveItems(ids, resolveInstruction, targetIdsOrPurposes, readOptions);
}
public async Task<PublishContextData[]> ResolveItemsAsync(string[] ids, ResolveInstructionData resolveInstruction, string[] targetIdsOrPurposes, ReadOptions readOptions)
{
return await Task<PublishContextData[]>.Factory.FromAsync(Channel.BeginResolveItems(ids, resolveInstruction, targetIdsOrPurposes, readOptions, null, null), Channel.EndResolveItems);
}
public XElement GetSearchResultsXml(SearchQueryData filter)
{
return Channel.GetSearchResultsXml(filter);
}
public async Task<XElement> GetSearchResultsXmlAsync(SearchQueryData filter)
{
return await Task<XElement>.Factory.FromAsync(Channel.BeginGetSearchResultsXml, Channel.EndGetSearchResultsXml, filter, null);
}
public XElement GetSearchResultsXmlPaged(SearchQueryData filter, int startRowIndex, int maxRows)
{
return Channel.GetSearchResultsXmlPaged(filter, startRowIndex, maxRows);
}
public async Task<XElement> GetSearchResultsXmlPagedAsync(SearchQueryData filter, int startRowIndex, int maxRows)
{
return await Task<XElement>.Factory.FromAsync(Channel.BeginGetSearchResultsXmlPaged, Channel.EndGetSearchResultsXmlPaged, filter, startRowIndex, maxRows, null);
}
public IdentifiableObjectData[] GetSearchResults(SearchQueryData filter)
{
return Channel.GetSearchResults(filter);
}
public async Task<IdentifiableObjectData[]> GetSearchResultsAsync(SearchQueryData filter)
{
return await Task<IdentifiableObjectData[]>.Factory.FromAsync(Channel.BeginGetSearchResults, Channel.EndGetSearchResults, filter, null);
}
public IdentifiableObjectData[] GetSearchResultsPaged(SearchQueryData filter, int startRowIndex, int maxRows)
{
return Channel.GetSearchResultsPaged(filter, startRowIndex, maxRows);
}
public async Task<IdentifiableObjectData[]> GetSearchResultsPagedAsync(SearchQueryData filter, int startRowIndex, int maxRows)
{
return await Task<IdentifiableObjectData[]>.Factory.FromAsync(Channel.BeginGetSearchResultsPaged, Channel.EndGetSearchResultsPaged, filter, startRowIndex, maxRows, null);
}
public RenderedItemData RenderItem(string itemId, string templateId, PublishInstructionData publishInstruction, string publicationTargetIdOrPurpose)
{
return Channel.RenderItem(itemId, templateId, publishInstruction, publicationTargetIdOrPurpose);
}
public async Task<RenderedItemData> RenderItemAsync(string itemId, string templateId, PublishInstructionData publishInstruction, string publicationTargetIdOrPurpose)
{
return await Task<RenderedItemData>.Factory.FromAsync(Channel.BeginRenderItem(itemId, templateId, publishInstruction, publicationTargetIdOrPurpose, null, null), Channel.EndRenderItem);
}
public RenderedItemData PreviewItem(RepositoryLocalObjectData itemData, TemplateData templateData, PublishInstructionData publishInstruction, string publicationTargetId)
{
return Channel.PreviewItem(itemData, templateData, publishInstruction, publicationTargetId);
}
public async Task<RenderedItemData> PreviewItemAsync(RepositoryLocalObjectData itemData, TemplateData templateData, PublishInstructionData publishInstruction, string publicationTargetId)
{
return await Task<RenderedItemData>.Factory.FromAsync(Channel.BeginPreviewItem(itemData, templateData, publishInstruction, publicationTargetId, null, null), Channel.EndPreviewItem);
}
public PublishTransactionData[] Publish(string[] ids, PublishInstructionData publishInstruction, string[] targetIdsOrPurposes, PublishPriority? priority, ReadOptions readOptions)
{
return Channel.Publish(ids, publishInstruction, targetIdsOrPurposes, priority, readOptions);
}
public async Task<PublishTransactionData[]> PublishAsync(string[] ids, PublishInstructionData publishInstruction, string[] targetIdsOrPurposes, PublishPriority? priority, ReadOptions readOptions)
{
return await Task<PublishTransactionData[]>.Factory.FromAsync(Channel.BeginPublish(ids, publishInstruction, targetIdsOrPurposes, priority, readOptions, null, null), Channel.EndPublish);
}
public PublishTransactionData[] UnPublish(string[] ids, UnPublishInstructionData unPublishInstruction, string[] targetIdsOrPurposes, PublishPriority? priority, ReadOptions readOptions)
{
return Channel.UnPublish(ids, unPublishInstruction, targetIdsOrPurposes, priority, readOptions);
}
public async Task<PublishTransactionData[]> UnPublishAsync(string[] ids, UnPublishInstructionData unPublishInstruction, string[] targetIdsOrPurposes, PublishPriority? priority, ReadOptions readOptions)
{
return await Task<PublishTransactionData[]>.Factory.FromAsync(Channel.BeginUnPublish(ids, unPublishInstruction, targetIdsOrPurposes, priority, readOptions, null, null), Channel.EndUnPublish);
}
public bool IsPublished(string itemId, string publishingTargetIdOrPurpose, bool isPublishedInContext)
{
return Channel.IsPublished(itemId, publishingTargetIdOrPurpose, isPublishedInContext);
}
public async Task<bool> IsPublishedAsync(string itemId, string publishingTargetIdOrPurpose, bool isPublishedInContext)
{
return await Task<bool>.Factory.FromAsync(Channel.BeginIsPublished, Channel.EndIsPublished, itemId, publishingTargetIdOrPurpose, isPublishedInContext, null);
}
public RenderedItemData GetWorkItemSnapshot(string workItemId)
{
return Channel.GetWorkItemSnapshot(workItemId);
}
public async Task<RenderedItemData> GetWorkItemSnapshotAsync(string workItemId)
{
return await Task<RenderedItemData>.Factory.FromAsync(Channel.BeginGetWorkItemSnapshot, Channel.EndGetWorkItemSnapshot, workItemId, null);
}
public PublishInfoData[] GetListPublishInfo(string itemId)
{
return Channel.GetListPublishInfo(itemId);
}
public async Task<PublishInfoData[]> GetListPublishInfoAsync(string itemId)
{
return await Task<PublishInfoData[]>.Factory.FromAsync(Channel.BeginGetListPublishInfo, Channel.EndGetListPublishInfo, itemId, null);
}
public ActionFlags CastActions(int numericActions)
{
return Channel.CastActions(numericActions);
}
public async Task<ActionFlags> CastActionsAsync(int numericActions)
{
return await Task<ActionFlags>.Factory.FromAsync(Channel.BeginCastActions, Channel.EndCastActions, numericActions, null);
}
public void ValidateXml(IdentifiableObjectData data)
{
Channel.ValidateXml(data);
}
public async Task ValidateXmlAsync(IdentifiableObjectData data)
{
await Task.Factory.FromAsync(Channel.BeginValidateXml, Channel.EndValidateXml, data, null);
}
public bool IsValidTridionWebSchemaXml(SchemaData data)
{
return Channel.IsValidTridionWebSchemaXml(data);
}
public async Task<bool> IsValidTridionWebSchemaXmlAsync(SchemaData data)
{
return await Task<bool>.Factory.FromAsync(Channel.BeginIsValidTridionWebSchemaXml, Channel.EndIsValidTridionWebSchemaXml, data, null);
}
public ArrayOfTcmUri GetSubjectIdsWithApplicationData(string applicationId)
{
return Channel.GetSubjectIdsWithApplicationData(applicationId);
}
public async Task<ArrayOfTcmUri> GetSubjectIdsWithApplicationDataAsync(string applicationId)
{
return await Task<ArrayOfTcmUri>.Factory.FromAsync(Channel.BeginGetSubjectIdsWithApplicationData, Channel.EndGetSubjectIdsWithApplicationData, applicationId, null);
}
public ApplicationDataDictionary ReadApplicationDataForSubjectsIds(string[] subjectIds, string[] applicationIds)
{
return Channel.ReadApplicationDataForSubjectsIds(subjectIds, applicationIds);
}
public async Task<ApplicationDataDictionary> ReadApplicationDataForSubjectsIdsAsync(string[] subjectIds, string[] applicationIds)
{
return await Task<ApplicationDataDictionary>.Factory.FromAsync(Channel.BeginReadApplicationDataForSubjectsIds, Channel.EndReadApplicationDataForSubjectsIds, subjectIds, applicationIds, null);
}
public SecurityDescriptorDataDictionary GetSecurityDescriptorsForSubjectsIds(string[] subjectIds)
{
return Channel.GetSecurityDescriptorsForSubjectsIds(subjectIds);
}
public async Task<SecurityDescriptorDataDictionary> GetSecurityDescriptorsForSubjectsIdsAsync(string[] subjectIds)
{
return await Task<SecurityDescriptorDataDictionary>.Factory.FromAsync(Channel.BeginGetSecurityDescriptorsForSubjectsIds, Channel.EndGetSecurityDescriptorsForSubjectsIds, subjectIds, null);
}
public SecurityDescriptorDataDictionary GetContentSecurityDescriptorsForOrgItemIds(string[] organizationalItemIds)
{
return Channel.GetContentSecurityDescriptorsForOrgItemIds(organizationalItemIds);
}
public async Task<SecurityDescriptorDataDictionary> GetContentSecurityDescriptorsForOrgItemIdsAsync(string[] organizationalItemIds)
{
return await Task<SecurityDescriptorDataDictionary>.Factory.FromAsync(Channel.BeginGetContentSecurityDescriptorsForOrgItemIds, Channel.EndGetContentSecurityDescriptorsForOrgItemIds, organizationalItemIds, null);
}
public void ReIndex(string id)
{
Channel.ReIndex(id);
}
public async Task ReIndexAsync(string id)
{
await Task.Factory.FromAsync(Channel.BeginReIndex, Channel.EndReIndex, id, null);
}
public PredefinedQueue? CastPredefinedQueue(int queueId)
{
return Channel.CastPredefinedQueue(queueId);
}
public async Task<PredefinedQueue?> CastPredefinedQueueAsync(int queueId)
{
return await Task<PredefinedQueue?>.Factory.FromAsync(Channel.BeginCastPredefinedQueue, Channel.EndCastPredefinedQueue, queueId, null);
}
public int PurgeOldVersions(PurgeOldVersionsInstructionData instruction)
{
return Channel.PurgeOldVersions(instruction);
}
public async Task<int> PurgeOldVersionsAsync(PurgeOldVersionsInstructionData instruction)
{
return await Task<int>.Factory.FromAsync(Channel.BeginPurgeOldVersions, Channel.EndPurgeOldVersions, instruction, null);
}
public XElement GetListExternalLinks(string id)
{
return Channel.GetListExternalLinks(id);
}
public async Task<XElement> GetListExternalLinksAsync(string id)
{
return await Task< XElement>.Factory.FromAsync(Channel.BeginGetListExternalLinks, Channel.EndGetListExternalLinks, id, null);
}
public SearchQueryData ConvertXmlToSearchQuery(XElement searchQueryXml)
{
return Channel.ConvertXmlToSearchQuery(searchQueryXml);
}
public async Task<SearchQueryData> ConvertXmlToSearchQueryAsync(XElement searchQueryXml)
{
return await Task<SearchQueryData>.Factory.FromAsync(Channel.BeginConvertXmlToSearchQuery, Channel.EndConvertXmlToSearchQuery, searchQueryXml, null);
}
public XElement ConvertSearchQueryToXml(SearchQueryData searchQueryData)
{
return Channel.ConvertSearchQueryToXml(searchQueryData);
}
public async Task<XElement> ConvertSearchQueryToXmlAsync(SearchQueryData searchQueryData)
{
return await Task<XElement>.Factory.FromAsync(Channel.BeginConvertSearchQueryToXml, Channel.EndConvertSearchQueryToXml, searchQueryData, null);
}
public VersionedItemData CheckIn(string id, ReadOptions readBackOptions)
{
return this.CheckIn(id, true, null, readBackOptions);
}
public SchemaFieldsData ConvertXsdToSchemaFields(XElement xsd, SchemaPurpose purpose, ReadOptions readOptions)
{
return this.ConvertXsdToSchemaFields(xsd, purpose, null, readOptions);
}
public void EnlistInTransaction()
{
Channel.EnlistInTransaction();
}
public async Task EnlistInTransactionAsync()
{
await Task.Factory.FromAsync(Channel.BeginEnlistInTransaction, Channel.EndEnlistInTransaction, null);
}
public string GetSessionId()
{
return Channel.GetSessionId();
}
public async Task<string> GetSessionIdAsync()
{
return await Task<string>.Factory.FromAsync(Channel.BeginGetSessionId, Channel.EndGetSessionId, null);
}
public int GetSessionTransactionTimeout()
{
return Channel.GetSessionTransactionTimeout();
}
public async Task<int> GetSessionTransactionTimeoutAsync()
{
return await Task<int>.Factory.FromAsync(Channel.BeginGetSessionTransactionTimeout, Channel.EndGetSessionTransactionTimeout, null);
}
public SchemaData GetVirtualFolderTypeSchema(string namespaceUri)
{
return Channel.GetVirtualFolderTypeSchema(namespaceUri);
}
public async Task<SchemaData> GetVirtualFolderTypeSchemaAsync(string namespaceUri)
{
return await Task<SchemaData>.Factory.FromAsync(Channel.BeginGetVirtualFolderTypeSchema, Channel.EndGetVirtualFolderTypeSchema, namespaceUri, null);
}
public Task<ActivityInstanceData> ResumeActivityActivity(string activityInstanceId, ReadOptions readOptions = null)
{
throw new NotImplementedException();
}
public void SetSessionContextData(ApplicationData appData)
{
Channel.SetSessionContextData(appData);
}
public async Task SetSessionContextDataAsync(ApplicationData appData)
{
await Task.Factory.FromAsync(Channel.BeginSetSessionContextData, Channel.EndSetSessionContextData, appData, null);
}
public void SetSessionTransactionTimeout(int transactionTimeout)
{
Channel.SetSessionTransactionTimeout(transactionTimeout);
}
public async Task SetSessionTransactionTimeoutAsync(int transactionTimeout)
{
await Task.Factory.FromAsync(Channel.BeginSetSessionTransactionTimeout, Channel.EndSetSessionTransactionTimeout, transactionTimeout, null);
}
public void SetWebDavUrlPrefix(string prefix)
{
Channel.SetWebDavUrlPrefix(prefix);
}
public async Task SetWebDavUrlPrefixAsync(string prefix)
{
await Task.Factory.FromAsync(Channel.BeginSetWebDavUrlPrefix, Channel.EndSetWebDavUrlPrefix, prefix, null);
}
public bool StartCaching()
{
return Channel.StartCaching();
}
public async Task<bool> StartCachingAsync()
{
return await Task<bool>.Factory.FromAsync(Channel.BeginStartCaching, Channel.EndStartCaching, null);
}
public void StopCaching()
{
Channel.StopCaching();
}
public async Task StopCachingAsync()
{
await Task.Factory.FromAsync(Channel.BeginStopCaching, Channel.EndStopCaching, null);
}
public void TerminateSession()
{
Channel.TerminateSession();
}
public async Task TerminateSessionAsync()
{
await Task.Factory.FromAsync(Channel.BeginTerminateSession, Channel.EndTerminateSession, null);
}
public PublishTransactionData UndoPublishTransaction(string publishTransactionId, QueueMessagePriority? priority = default(QueueMessagePriority?), ReadOptions readBackOptions = null)
{
throw new NotImplementedException();
}
public Task<PublishTransactionData> UndoPublishTransactionAsync(string publishTransactionId, QueueMessagePriority? priority = default(QueueMessagePriority?), ReadOptions readBackOptions = null)
{
throw new NotImplementedException();
}
public UserData GetCurrentUser()
{
throw new NotImplementedException();
}
public Task<UserData> GetCurrentUserAsync()
{
throw new NotImplementedException();
}
/// <summary>
/// Finalizer
/// </summary>
~AlchemyCoreServiceClient201603()
{
Dispose(false);
}
}
}
|
2f8e23484d84845f47fccde5a3d32d018125e488
|
C#
|
velev1/HomeworkTA
|
/UnitTesting/UnitTestingHomework/StudentsAndCourses/Course.cs
| 3.34375
| 3
|
namespace StudentsAndCourses
{
using System.Collections.Generic;
using CoursesEnum;
public class Course
{
private ICollection<Student> programmingList;
private ICollection<Student> mathList;
private ICollection<Student> algorithms;
public Course()
{
programmingList = new List<Student>();
mathList = new List<Student>();
algorithms = new List<Student>();
//AddStudentToCourse(new Student("Pesho"), CourseName.math);
//AddStudentToCourse(new Student("Ivan"), CourseName.math);
//AddStudentToCourse(new Student("Dragan"), CourseName.math);
}
public void AddStudentToCourse(Student student, CourseName course)
{
switch (course)
{
case CourseName.programming:
if (GetCountOfStudents(CourseName.programming) < 30)
{
programmingList.Add(student);
}
break;
case CourseName.math:
if (GetCountOfStudents(CourseName.math) < 30)
{
mathList.Add(student);
}
break;
case CourseName.algorithms:
if (GetCountOfStudents(CourseName.algorithms) < 30)
{
algorithms.Add(student);
}
break;
}
}
public void RemoveStudentFromCourse(Student student, CourseName course)
{
switch (course)
{
case CourseName.programming:
programmingList.Remove(student);
break;
case CourseName.math:
mathList.Remove(student);
break;
case CourseName.algorithms:
algorithms.Remove(student);
break;
}
}
public int GetCountOfStudents(CourseName course)
{
int count = 0;
switch (course)
{
case CourseName.programming:
count = programmingList.Count;
break;
case CourseName.math:
count = mathList.Count;
break;
case CourseName.algorithms:
count = algorithms.Count;
break;
}
return count;
}
}
}
|
bcc539e658dee08f0f96d0a0d8567e7e73e63b2a
|
C#
|
brendonwanderlust/TicTacToeCSharp
|
/TicTacToeCSharp/UI.cs
| 3.234375
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TicTacToeCSharp.Players;
namespace TicTacToeCSharp
{
public static class UI
{
public static void DisplayGameBoardComponent(GameState game)
{
Console.WriteLine(" 1 2 3");
Console.WriteLine(" | |");
Console.WriteLine($"1 {GridLocationComponent(game.Row1[0])} | {GridLocationComponent(game.Row1[1])} | {GridLocationComponent(game.Row1[2])}");
Console.WriteLine(" _____|_____|_____");
Console.WriteLine(" | |");
Console.WriteLine($"2 {GridLocationComponent(game.Row2[0])} | {GridLocationComponent(game.Row2[1])} | {GridLocationComponent(game.Row2[2])}");
Console.WriteLine(" _____|_____|_____");
Console.WriteLine(" | |");
Console.WriteLine($"3 {GridLocationComponent(game.Row3[0])} | {GridLocationComponent(game.Row3[1])} | {GridLocationComponent(game.Row3[2])}");
Console.WriteLine(" | |");
}
public static string GridLocationComponent(string location)
{
var locationString = " ";
if (!string.IsNullOrEmpty(location))
{
locationString = location;
return locationString;
}
return locationString;
}
public static bool InputIsAcceptable(string input)
{
if (input.Length != 3 || string.IsNullOrEmpty(input) || string.IsNullOrWhiteSpace(input))
{
CorrectFormatReminderMessage();
return false;
}
if (input.Any(char.IsLetter))
{
Console.WriteLine("Your input should not contain letters.");
CorrectFormatReminderMessage();
return false;
}
if (!input.Contains('.'))
{
Console.WriteLine("Your input should include a period.");
CorrectFormatReminderMessage();
return false;
}
if (input[1] != '.')
{
Console.WriteLine("Your input should include a period as a center separator.");
CorrectFormatReminderMessage();
return false;
}
var xAxis= int.Parse($"{input[0]}");
var yAxis = int.Parse($"{input[2]}");
if (xAxis > 3 || yAxis > 3 || xAxis == 0 || yAxis == 0)
{
Console.WriteLine("X and Y Axis values should be between 1 and 3");
CorrectFormatReminderMessage();
return false;
}
return true;
}
private static void CorrectFormatReminderMessage()
{
Console.WriteLine("The correct format should include a X axis value between (1 - 3) followed by a period (.) followed by a Y axis value between (1 - 3). For example: 1.3 or 2.1");
Console.WriteLine("");
}
private static void PleaseEnterCorrectFormatMessage()
{
Console.WriteLine("Please enter the correct format.");
}
public static void PlayerTakesTurn(GameState game, PlayerBase player)
{
while (true)
{
Console.WriteLine($"Where you like to place the {player.Symbol}");
string input = Console.ReadLine();
if (!InputIsAcceptable(input))
{
continue;
}
var xAxis = int.Parse($"{input[0]}");
var yAxis = int.Parse($"{input[2]}");
if (GameLogic.HasLocationAlreadyBeenSelected(game, xAxis, yAxis))
{
continue;
}
GameLogic.SetSymbolAtLocation(game, player, xAxis, yAxis);
break;
}
}
public static void InitializeGame(GameState game)
{
bool gameOn = true;
DisplayGameBoardComponent(game);
while (gameOn)
{
if (game.WinnerOrTieExists == false)
{
PlayerTakesTurn(game, game.O);
GameLogic.CheckForWinner(game);
DisplayGameBoardComponent(game);
}
if (game.WinnerOrTieExists == false)
{
PlayerTakesTurn(game, game.X);
GameLogic.CheckForWinner(game);
DisplayGameBoardComponent(game);
}
if (game.WinnerOrTieExists == true)
{
gameOn = false;
}
}
}
}
}
|
02401cfcc10e81c16e03eced237d9c28e1af9036
|
C#
|
ThatMadMf/nmcs
|
/labs_nmcs/LabsFactory.cs
| 2.890625
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace labs_nmcs {
class LabsFactory {
public static Lab getLab(Labs lab) {
switch (lab) {
case Labs.Eluler:
return new Lab6.Euler(1, 0, 0.9, 0.05, "2*[x]*[y]*[y]");
case Labs.Milne:
return new Lab7.Milne(0, 5, 1, "[y]+3*[x]-Pow([x],2)");
default:
throw new Exception("Not implemented");
}
}
}
}
|
a29e31ca8aff6f9bd69be2425e701b2d9c069c19
|
C#
|
TheDotaWeirdo/Extensions
|
/Extensions/Extensions/Threading Extensions.cs
| 3.484375
| 3
|
using System;
using System.Threading;
namespace Extensions
{
public static partial class ExtensionClass
{
/// <summary>
/// Runs an <see cref="Action"/> in the background
/// </summary>
/// <param name="Priority">The <see cref="ThreadPriority"/> of the background <see cref="Thread"/></param>
public static Thread RunInBackground(this Action A, ThreadPriority Priority = ThreadPriority.Normal)
{
var t = new Thread(new ThreadStart(A)) { IsBackground = true, Priority = Priority };
t.Start();
return t;
}
/// <summary>
/// Runs an <see cref="Action"/> in the background after a delay
/// </summary>
/// <param name="Delay"><see cref="Action"/> delay in milliseconds</param>
/// <param name="RunOnce">Option to run the <see cref="Action"/> once or repeating after each <paramref name="Delay"/></param>
public static void RunInBackground(this Action A, int Delay, bool RunOnce = true)
{
var T = new System.Timers.Timer(Math.Max(1, Delay)) { AutoReset = !RunOnce };
T.Elapsed += (s, e) => A();
T.Start();
}
/// <summary>
/// Loops an <see cref="Action"/> in the background until the <paramref name="condition"/> is met
/// <param name="onEnd"><see cref="Action"/> to execute at the end</param>
/// </summary>
public static Thread TimerLoop(this Action action, Func<bool> condition, Action onEnd = null, ThreadPriority priority = ThreadPriority.Normal)
{
if (action == null)
throw new ArgumentNullException(nameof(action));
if (condition == null)
throw new ArgumentNullException(nameof(condition));
var T = new Thread(() =>
{
while (condition())
action();
onEnd?.Invoke();
})
{
IsBackground = true,
Priority = priority
};
T.Start();
return T;
}
}
}
|
dc202dc2d54b47332c607d448a90d7ee849f5d25
|
C#
|
SenkoVlad/Patterns
|
/Core/Patterns/Structural Design Patterns/Adapter/RoundHole.cs
| 2.75
| 3
|
using Patterns.Structural_Design_Patterns.Adapter;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Patterns.Structural_Design_Patterns.Addapter
{
public class RoundHole
{
protected int radius;
public RoundHole(int radius)
{
this.radius = radius;
}
public int getRadius()
{
return radius;
}
public bool Fits(IRound peg)
{
return radius >= peg.getRadius();
}
}
}
|
944878cd85583d4a3bd8c7dd3a6ae5a379497a90
|
C#
|
dimitri20/davaleba4
|
/calculatorWithSwitch/calculatorWithSwitch/Program.cs
| 3.59375
| 4
|
using System;
namespace calculatorWithSwitch
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("kalkulatori: \n\n");
while (true)
{
Console.Write("sheiyvanet pirveli ricxvi: ");
double firstNumber = Convert.ToDouble(Console.ReadLine());
Console.Write("sheiyvanet operacia: ");
string operation = Console.ReadLine();
Console.Write("sheiyvanet meore ricxvi: ");
double secondNumber = Convert.ToDouble(Console.ReadLine());
double final = 0;
bool canDisplay = true;
switch (operation)
{
case "+":
final = firstNumber + secondNumber;
break;
case "-":
final = firstNumber - secondNumber;
break;
case "*":
final = firstNumber * secondNumber;
break;
case "/":
if(secondNumber != 0)
{
final = firstNumber / secondNumber;
} else
{
canDisplay = false;
Console.WriteLine("nulze gayofa ar sheidzleba ");
Console.WriteLine("scadet tavidan \n");
}
break;
default:
Console.WriteLine("tqven sheiyvanet araswori operacia");
Console.WriteLine("scadet tavidan \n");
break;
}
if (canDisplay)
{
Console.WriteLine($"{firstNumber} {operation} {secondNumber} = {final}");
}
}
}
}
}
|
5363d19f9d541f962df0dca56308bd311679eed7
|
C#
|
dotlogix/DotlogixCore
|
/WebServices/WebServices.Core/Terms/ManyTerm.cs
| 2.546875
| 3
|
#region
using System.Collections;
using System.Collections.Generic;
using DotLogix.Core.Extensions;
using DotLogix.WebServices.Core.Serialization;
using Newtonsoft.Json;
#endregion
namespace DotLogix.WebServices.Core.Terms;
[JsonConverter(typeof(ManyTermJsonConverter<>))]
public class ManyTerm<T> : IReadOnlyList<T> {
public int Count => Values.Count;
public T this[int index] => Values[index];
public IReadOnlyList<T> Values { get; set; }
public ManyTerm() {
}
public ManyTerm(IEnumerable<T> values) {
Values = values.AsReadOnlyList();
}
public ManyTerm(T value) {
Values = value.CreateArray();
}
public IEnumerator<T> GetEnumerator() => Values.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)Values).GetEnumerator();
public static implicit operator ManyTerm<T>(T value) => new ManyTerm<T>(value);
public static implicit operator ManyTerm<T>(T[] values) => new ManyTerm<T>(values);
public static implicit operator ManyTerm<T>(List<T> values) => new ManyTerm<T>(values);
}
|
42d9669bc1ef7e8e39a64efeb920f44aea5cbe55
|
C#
|
madilynsimons/Snakes
|
/Attack.cs
| 3.171875
| 3
|
// Attack.cs
using System;
public class Attack
{
readonly int DEFAULTID = -1;
readonly int DEFAULTPP = 20;
readonly string DEFAULTNAME = null;
readonly int DEFAULTSIZE = 1;
public int Id;
public string Name;
public int Slots;
public int MaxPP, CurrentPP;
/** Constructors **/
public Attack()
{
Id = DEFAULTID;
Name = DEFAULTNAME;
MaxPP = DEFAULTPP;
Slots = DEFAULTSIZE;
Init();
}
public Attack(Attack a)
{
Id = a.Id;
Name = a.Name;
MaxPP = a.MaxPP;
Slots = a.Slots;
Init();
}
public Attack(string Input)
{
string[] Space = new string[]{" "};
string[] Parsed;
Parsed = Input.Split(Space, StringSplitOptions.None);
Id = int.Parse(Parsed[0]);
Name = Parsed[1];
MaxPP = int.Parse(Parsed[2]);
Slots = int.Parse(Parsed[3]);
Init();
}
void Init()
{
CurrentPP = MaxPP;
}
public void Print()
{
Console.WriteLine("********************");
Console.WriteLine("ID = " + Id);
Console.WriteLine("NAME = " + Name);
Console.WriteLine("PP = " + MaxPP);
Console.WriteLine("SLOTS = " + Slots);
Console.WriteLine("********************");
}
}
|
243cd8a7757aa9757227942e7c2ebc71d1ca50dc
|
C#
|
owenbartley/logbook
|
/NewTrip.cs
| 2.6875
| 3
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Xml;
using System.Xml.Linq;
namespace DriversLogbookApp
{
public partial class NewTrip : Form
{
public NewTrip()
{
InitializeComponent();
}
//Store file path
string filePath = "trips.xml";
bool start = true;
//Get todays date
string date = DateTime.Now.ToShortDateString();
public class Trip
{
public string date;
public double duration;
public bool weatherRain;
public bool weatherClear;
public bool trafficLight;
public bool trafficMed;
public bool trafficHeavy;
public bool roadLocal;
public bool roadHighway;
public bool roadRural;
public bool day;
public bool approved;
}
private void BtnStartStop_Click(object sender, EventArgs e)
{
//Turn button into switch and start timer
//Start button
if (start == true)
{
//Change button to 'stop' button
btnStartStop.Text = "Stop";
start = false;
//Start the timer from 0
elapsedTime = 0;
timer1.Start();
}
//Stop button
else
{
//Stop the timer and store the elapsed time
timer1.Stop();
double duration = elapsedTime;
//Add input data into array
Trip t = new Trip();
t.duration = Convert.ToDouble(duration);
t.weatherClear = chkBxClear.Checked;
t.weatherRain = chkBxRain.Checked;
t.trafficLight = chkBxLight.Checked;
t.trafficMed = chkBxMed.Checked;
t.trafficHeavy = chkBxHeavy.Checked;
t.roadLocal = chkBxLocal.Checked;
t.roadRural = chkBxRural.Checked;
t.roadHighway = chkBxHighway.Checked;
t.day = chkBxTime.Checked;
t.approved = chkBxApproved.Checked;
//Validate input data
//Validate weather
if(t.weatherClear == false & t.weatherRain == false)
{
MessageBox.Show("No Weather Selected", "Error");
}
else
{
//Validate traffic
if (t.trafficLight == false & t.trafficMed == false & t.trafficHeavy == false)
{
MessageBox.Show("No Traffic Level Selected", "Error");
}
else
{
//Validate road type
if (t.roadLocal == false & t.roadRural == false & t.roadHighway == false)
{
MessageBox.Show("No Road Type Selected", "Error");
}
else
{
//Save data to XML document
WriteTripData(t);
//Go back to Home form
Hide();
Home newHomeForm = new Home();
newHomeForm.ShowDialog();
}
}
}
}
}
public void WriteTripData(Trip t)
{
//Load document
XDocument xmlDoc = XDocument.Load(filePath);
if (!File.Exists(filePath))
{
//Append input data into XML
xmlDoc.Element("driverslog").Add(new XElement("trip"), new XElement("duration", Convert.ToString(t.duration)), new XElement("date", date), new XElement("rain", Convert.ToString(t.weatherRain)), new XElement("clear", Convert.ToString(t.weatherClear)), new XElement("light", Convert.ToString(t.trafficLight)), new XElement("med", Convert.ToString(t.trafficMed)), new XElement("heavy", Convert.ToString(t.trafficHeavy)), new XElement("local", Convert.ToString(t.roadLocal)), new XElement("rural", Convert.ToString(t.roadRural)), new XElement("highway", Convert.ToString(t.roadHighway)), new XElement("day", Convert.ToString(t.day)), new XElement("approved", Convert.ToString(t.approved)));
}
else
{
//Create XML document and add input data
XElement root = xmlDoc.Element("driverslog");
IEnumerable<XElement> rows = root.Descendants("trip");
XElement firstRow = rows.First();
firstRow.AddBeforeSelf(
new XElement("trip",
new XElement("duration", t.duration),
new XElement("date", date),
new XElement("rain", t.weatherRain),
new XElement("clear", t.weatherClear),
new XElement("light", t.trafficLight),
new XElement("med", t.trafficMed),
new XElement("heavy", t.trafficHeavy),
new XElement("local", t.roadLocal),
new XElement("rural", t.roadRural),
new XElement("highway", t.roadHighway),
new XElement("day", t.day),
new XElement("approved", t.approved)));
}
//Save document
xmlDoc.Save(filePath);
}
int elapsedTime = 0;
private void Timer1_Tick(object sender, EventArgs e)
{
//Add a second every tick to elapsed time
elapsedTime = elapsedTime + 1;
var time = TimeSpan.FromSeconds(elapsedTime);
//Get current duration and display it
lblDuration.Text = time.ToString();
}
private void NewTrip_Load(object sender, EventArgs e)
{
//Load XML document
XmlDocument doc = new XmlDocument();
doc.Load(filePath);
//Get todays date and display it
lblDate.Text = date;
}
private void CheckBox6_CheckedChanged(object sender, EventArgs e)
{
}
private void CheckBox5_CheckedChanged(object sender, EventArgs e)
{
}
private void CheckBox4_CheckedChanged(object sender, EventArgs e)
{
}
private void ChkBxClear_CheckedChanged(object sender, EventArgs e)
{
}
}
}
|
302ed052dd344342a68adc2e42b275d18ab14c7b
|
C#
|
njg/songlyricsstatis
|
/phoneticTable/repairer/EndingRepairerEd.cs
| 2.890625
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace LyricThemeClassifier
{
class EndingRepairerEd : EndingRepairer
{
#region Public Methods
public override bool IsMatchEndingType(string wordVariant, string shortHomophone)
{
return wordVariant == shortHomophone + "ed" || (wordVariant == shortHomophone + "d" && shortHomophone.EndsWith("e"));
}
public override string BuildPhoneticEnding(string phoneticValue)
{
/*
* ending with: [treg] or [dreg] + facultative [*prime] -> [ibreve] [dreg]
* ending with: [preg], [freg], [sreg], [sreg] [hreg], [creg] [hreg] or [kreg] + facultative [*prime] -> [treg] [lprime]
* else: [dreg] [lprime]
*/
phoneticValue = phoneticValue.Replace("[lprime]", "");
phoneticValue = phoneticValue.Replace("[prime]", "");
while (phoneticValue.Contains(" "))
phoneticValue = phoneticValue.Replace(" ", " ");
phoneticValue = phoneticValue.Trim();
string phoneticEnding;
if (phoneticValue.EndsWith("[treg]") || phoneticValue.EndsWith("[dreg]"))
{
phoneticEnding = "[ibreve] [dreg]";
}
else if (phoneticValue.EndsWith("[preg]") || phoneticValue.EndsWith("[freg]") || phoneticValue.EndsWith("[sreg]") || phoneticValue.EndsWith("[sreg] [hreg]") || phoneticValue.EndsWith("[creg] [hreg]") || phoneticValue.EndsWith("[kreg]"))
{
phoneticEnding = "[treg]";
}
else
{
phoneticEnding = "[dreg]";
}
return phoneticEnding;
}
#endregion
}
}
|
6c8777f9c735818b40bed6e0013210bd6805e00a
|
C#
|
Bozhikov99/Csharp-Fundamentals
|
/03. Arrays/Arrays - Exercise/3. Zig Zag/Program.cs
| 3.5
| 4
|
using System;
using System.Linq;
namespace _3._Zig_Zag
{
class Program
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int[] up = new int[n];
int[] down= new int[n];
for (int i = 0; i < n; i++)
{
int[] twoNums = Console.ReadLine()
.Split()
.Select(int.Parse)
.ToArray();
int nula = twoNums[0];
int one = twoNums[1];
if (i%2==0)
{
up[i] = nula;
down[i] = one;
}
else
{
up[i] = one;
down[i] = nula;
}
}
Console.WriteLine(string.Join(" ", up));
Console.WriteLine(string.Join(" ", down));
}
}
}
|
a688b95e040179ad6027ee058d92c5499507a1ff
|
C#
|
AndreaQuintero20104/SolucionFinal
|
/Presentacion/PantallaGraficoDueño.cs
| 2.53125
| 3
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using LogicaNegocio;
using AccesoDatos;
using System.Windows.Forms.DataVisualization.Charting;
namespace Presentacion
{
public partial class PantallaGraficoDueño : Form
{
public PantallaGraficoDueño()
{
InitializeComponent();
}
private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
this.Close();
}
private void PantallaGraficoDueño_Load(object sender, EventArgs e)
{
GestorEstablecimientos gestor = new GestorEstablecimientos(new Data());
DtMostrarDatos.DataSource = gestor.graficaDueño(label5.Text);
List<string> establecimientos = new List<string>();
List<string> NumeroCitas = new List<string>();
foreach (DataGridViewRow row in DtMostrarDatos.Rows)
{
string establecimiento = Convert.ToString(row.Cells["Nombre"].Value);
establecimientos.Add(establecimiento);
}
foreach (DataGridViewRow row in DtMostrarDatos.Rows)
{
string citas = Convert.ToString(row.Cells["Numero de Citas"].Value);
NumeroCitas.Add(citas);
}
for (int i = 0; i < establecimientos.Count; i++)
{
Series serie = chart1.Series.Add(establecimientos[i]);
serie.Label = NumeroCitas[i].ToString();
serie.Points.Add(Convert.ToDouble(NumeroCitas[i]));
}
}
}
}
|
66cb70d66fbea213738c8a880c4dec01d51b9220
|
C#
|
thebluecode/SOLID-Samples
|
/SingleResponsibilityExample/AfterRefactoring/Example.cs
| 3.390625
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AfterRefactoring
{
public class Product
{
public string Name { get; set; }
public int Price { get; set; }
public Product(string name, int price)
{
this.Name = name;
this.Price = price;
}
}
public class Repository
{
public void Save(Product product)
{
Console.WriteLine("Saving Product: {{ Name: '{0}', Price: {1} }}", product.Name, product.Price);
}
}
public class Mailer
{
public void Email(Product product)
{
Console.WriteLine("Emailing Product: {{ Name: '{0}', Price: {1} }}", product.Name, product.Price);
}
}
}
|
8eaa347d0a69754bda4b9986aa7e6518fe508b51
|
C#
|
KevinCRR/KingWilliamHotel
|
/KingWIlliamApp/KingWilliamApp/frmViewStaff.cs
| 2.5625
| 3
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace KingWilliamApp
{
public partial class frmViewStaff : Form
{
public frmViewStaff()
{
InitializeComponent();
}
private void frmViewStaff_Load(object sender, EventArgs e)
{
RefreshList();
}
public void RefreshList()
{
PopulateData(Staff.GetAll());
}
void PopulateData(List<Staff> staff)
{
dgvStaff.Rows.Clear();
foreach (Staff s in staff)
{
dgvStaff.Rows.Add(new object[]
{
s.StaffID,
s.FirstName,
s.LastName,
s.PhoneNumber,
s.AddressID,
s.PositionID,
s.Salary,
s.HiredDate,
s.TerminationDate,
"Edit",
"Delete"
});
dgvStaff.Rows[dgvStaff.RowCount - 1].Tag = s;
}
}
private void btnNew_Click(object sender, EventArgs e)
{
}
private void dgvStaff_CellClick(object sender, DataGridViewCellEventArgs e)
{
}
}
}
|
e46dfdd9db8e76c389b0956f105e5857e8251749
|
C#
|
Nobuna-no/Unity-Tools
|
/Unity-Tools/Assets/00-UNITY-TOOLS/Production/Sources/UtilityModules/Physics/Physics2DUtility.cs
| 2.6875
| 3
|
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public static class Physics2DUtility
{
public static class CollisionMatrixLayerMasks
{
private static Dictionary<int, int> masksByLayer;
public static void Init()
{
masksByLayer = new Dictionary<int, int>();
for (int i = 0; i < 32; i++)
{
int mask = 0;
for (int j = 0; j < 32; j++)
{
if (!Physics2D.GetIgnoreLayerCollision(i, j))
{
mask |= 1 << j;
}
}
masksByLayer.Add(i, mask);
//Debug.Log("PhysicsCollisionMatrixLayerMasks Init["+ LayerMask.LayerToName(i) +"]" + string.Format("#{0:X}", mask));
}
}
public static int MaskForLayer(int layer)
{
if (masksByLayer == null)
{
Init();
}
return masksByLayer[layer];
}
}
/// <summary>
/// Compute an horizontal raycast to try to detect a ground.
/// </summary>
/// <param name="origin">Origin of the boundaries.</param>
/// <param name="refCollider">Reference collider for boundary calculations.</param>
/// <param name="layerMask">Physics layer to detect.</param>
/// <param name="drawDebug">May draw gizmos?</param>
/// <param name="debugDuration">Duration of the drawn debug.</param>
/// <returns></returns>
public static Collider2D ComputeHorizontalRaycast(Vector2 origin, Collider2D refCollider, LayerMask layerMask, bool drawDebug = false, float debugDuration = 0f)
{
return ComputeHorizontalRaycast(origin, refCollider, layerMask, drawDebug, debugDuration, Color.red);
}
public static Collider2D ComputeHorizontalRaycast(Vector2 origin, Collider2D refCollider, LayerMask layerMask, bool DrawDebug, float debugDuration, Color debugColor)
{
float ratioX = 0.3f;
origin.y -= refCollider.bounds.size.y * 0.55f - refCollider.offset.y;
origin.x -= refCollider.bounds.size.x * ratioX;
float distance = refCollider.bounds.size.x * ratioX * 2;
//int layer = CollisionMatrixLayerMasks.MaskForLayer(objectLayer);
if (DrawDebug)
{
//Debug.Log("[LOG]<Physics2DUtility>: PhysicsCollisionMatrixLayerMasks[" + LayerMask.LayerToName(objectLayer) + "]: " + string.Format("#{0:X}", layer));
Debug.DrawRay(origin, Vector3.right * distance, debugColor, debugDuration);
}
RaycastHit2D[] hitInfos = Physics2D.RaycastAll(origin, Vector2.right, distance, layerMask);
for (int i = 0; i < hitInfos.Length; ++i)
{
Collider2D current = hitInfos[i].collider;
if (current && !current.isTrigger)
{
return current;
}
}
return null;
}
/// <summary>
/// Compute an horizontal raycast to try to detect a wall.
/// </summary>
/// <param name="origin">Origin of the boundaries.</param>
/// <param name="refCollider">Reference collider for boundary calculations. (i.e. the player collider)</param>
/// <param name="forward">The reference to the front of the place where raycast.</param>
/// <param name="layer">Physics layer to detect.</param>
/// <param name="drawDebug">May draw gizmos?</param>
/// <param name="debugDuration">Duration of the drawn debug.</param>
/// <returns></returns>
public static Collider2D ComputeVerticalRay(Vector2 origin, Collider2D refCollider, float forward, LayerMask layer, bool drawDebug = false, float debugDuration = 0f)
{
return ComputeVerticalRay(origin, refCollider, forward, layer, drawDebug, debugDuration, Color.red);
}
public static Collider2D ComputeVerticalRay(Vector2 origin, Collider2D refCollider, float forward, LayerMask layer, bool DrawDebug, float debugDuration, Color debugColor)
{
float distance = refCollider.bounds.size.y * 0.75f;
origin.x += forward * refCollider.bounds.size.x * 0.55f + (forward * 0.1f);
origin.y += refCollider.bounds.size.y * 0.4f + refCollider.offset.y;
if (DrawDebug)
{
//Debug.Log("[LOG]<Physics2DUtility>: PhysicsCollisionMatrixLayerMasks[" + LayerMask.LayerToName(objectLayer) + "]: " + string.Format("#{0:X}", layer));
Debug.DrawRay(origin, Vector3.down * distance, debugColor, debugDuration);
}
RaycastHit2D[] hitInfos = Physics2D.RaycastAll(origin, Vector2.down, distance, layer);
for (int i = 0; i < hitInfos.Length; ++i)
{
Collider2D current = hitInfos[i].collider;
if (current && !current.isTrigger)
{
return current;
}
}
return null;
}
/// <summary>
/// Compute an horizontal raycast to try to detect a ground. This version allow the use of @objectLayer to work with the physics layer of the object as mask of the ray.
/// </summary>
/// <param name="origin">Origin of the boundaries.</param>
/// <param name="refCollider">Reference collider for boundary calculations.</param>
/// <param name="objectLayer">The object layer (gameObject.layer).</param>
/// <param name="drawDebug">May draw gizmos?</param>
/// <param name="debugDuration">Duration of the drawn debug.</param>
/// <returns></returns>
public static Collider2D ComputeHorizontalRaycast(Vector2 origin, Collider2D refCollider, int objectLayer, bool drawDebug = false, float debugDuration = 0f)
{
return ComputeHorizontalRaycast(origin, refCollider, objectLayer, drawDebug, debugDuration, Color.red);
}
public static Collider2D ComputeHorizontalRaycast(Vector2 origin, Collider2D refCollider, int objectLayer, bool drawDebug, float debugDuration, Color color)
{
origin.y -= refCollider.bounds.size.y * 0.55f - refCollider.offset.y;
origin.x -= refCollider.bounds.size.x * 0.3f;
float distance = refCollider.bounds.size.x * 0.8f;
int layer = CollisionMatrixLayerMasks.MaskForLayer(objectLayer);
if (drawDebug)
{
Debug.DrawRay(origin, Vector3.right * distance, color, debugDuration);
}
RaycastHit2D hitInfos = Physics2DUtility.RaycastAllWithEffector(origin, Vector2.right, distance, layer, drawDebug);
return hitInfos ? hitInfos.collider : null;
}
public static Collider2D ComputeVerticalRayWithoutEffector(Vector2 origin, Collider2D refCollider, float forward, int objectLayer, bool drawDebug = false, float debugDuration = 0f)
{
float distance = refCollider.bounds.size.y * 0.75f;
origin.x += forward * refCollider.bounds.size.x * 0.55f + (forward * 0.1f);
origin.y += refCollider.bounds.size.y * 0.4f + refCollider.offset.y;
int layer = CollisionMatrixLayerMasks.MaskForLayer(objectLayer);
if(drawDebug)
{
Debug.DrawRay(origin, Vector3.down * distance, Color.red, debugDuration);
}
RaycastHit2D hitInfos = Physics2DUtility.RaycastAllWithoutEffector(origin, Vector2.down, distance, layer, drawDebug);
return hitInfos ? hitInfos.collider : null;
}
public static Collider2D ComputeVerticalRayWithEffector(Vector2 origin, Collider2D refCollider, float forward, int objectLayer, bool drawDebug = false, float debugDuration = 0f)
{
float distance = refCollider.bounds.size.y * 0.75f;
origin.x += forward * refCollider.bounds.size.x * 0.55f + (forward * 0.1f);
origin.y += refCollider.bounds.size.y * 0.4f + refCollider.offset.y;
int layer = CollisionMatrixLayerMasks.MaskForLayer(objectLayer);
if (drawDebug)
{
Debug.DrawRay(origin, Vector3.down * distance, Color.red, debugDuration);
}
RaycastHit2D hitInfos = Physics2DUtility.RaycastAllWithEffector(origin, Vector2.down, distance, layer, drawDebug);
return hitInfos ? hitInfos.collider : null;
}
/// <summary>
/// Compute a raycast all and return the first collider non trigger found. Return an empty RaycastHit2D if nothing found.
/// </summary>
/// <param name="origin"></param>
/// <param name="direction"></param>
/// <param name="distance"></param>
/// <param name="layerMask"></param>
/// <param name="debug"></param>
/// <returns></returns>
public static RaycastHit2D RaycastAll(Vector2 origin, Vector2 direction, float distance, LayerMask layerMask, bool debug)
{
return RaycastAll(origin, direction, distance, layerMask, debug, Color.magenta, 5f);
}
public static RaycastHit2D RaycastAll(Vector2 origin, Vector2 direction, float distance, LayerMask layerMask, bool debug, Color color, float duration = 0f)
{
RaycastHit2D[] hitInfos = Physics2D.RaycastAll(origin, direction, distance, layerMask);
if (debug)
{
Debug.DrawRay(origin, direction * distance, color, duration);
}
for (int i = 0; i < hitInfos.Length; ++i)
{
Collider2D current = hitInfos[i].collider;
if (current && !current.isTrigger )
{
return hitInfos[i];
}
}
return new RaycastHit2D();
}
public static RaycastHit2D RaycastAllWithEffector(Vector2 origin, Vector2 direction, float distance, LayerMask layerMask, bool debug)
{
return RaycastAllWithEffector(origin, direction, distance, layerMask, debug, Color.magenta, 5f);
}
public static RaycastHit2D RaycastAllWithEffector(Vector2 origin, Vector2 direction, float distance, LayerMask layerMask, bool debug, Color color, float duration = 0f)
{
RaycastHit2D[] hitInfos = Physics2D.RaycastAll(origin, direction, distance, layerMask);
if (debug)
{
Debug.DrawRay(origin, direction * distance, color, duration);
}
for (int i = 0; i < hitInfos.Length; ++i)
{
Collider2D current = hitInfos[i].collider;
if (current && !current.isTrigger)
{
if (current.usedByEffector && direction.y >= 0)
{
break;
}
return hitInfos[i];
}
}
return new RaycastHit2D();
}
public static RaycastHit2D RaycastAllWithoutEffector(Vector2 origin, Vector2 direction, float distance, LayerMask layerMask, bool debug)
{
return RaycastAllWithoutEffector(origin, direction, distance, layerMask, debug, Color.magenta, 5f);
}
public static RaycastHit2D RaycastAllWithoutEffector(Vector2 origin, Vector2 direction, float distance, LayerMask layerMask, bool debug, Color color, float duration = 0f)
{
RaycastHit2D[] hitInfos = Physics2D.RaycastAll(origin, direction, distance, layerMask);
if (debug)
{
Debug.DrawRay(origin, direction * distance, color, duration);
}
for (int i = 0; i < hitInfos.Length; ++i)
{
Collider2D current = hitInfos[i].collider;
if (current && !current.isTrigger && !current.usedByEffector)
{
return hitInfos[i];
}
}
return new RaycastHit2D();
}
}
|
e14781b23c4382f21ced4ff861d8736899ddb129
|
C#
|
renber/AvisNet
|
/Avis.Common/IO/Messages/ErrorMessage.cs
| 2.84375
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Avis.IO.Messages
{
public class ErrorMessage : SyntheticMessage
{
public const int ID = -1;
public Exception Error { get; private set; }
public Message Cause { get; private set; }
public override int TypeId
{
get { return ID; }
}
public ErrorMessage(Exception error, Message cause)
{
Error = error;
Cause = cause;
}
/// <summary>
/// Generate an error message suitable for presentation as a debugging aid.
/// </summary>
/// <returns></returns>
public String FormattedMessage
{
get
{
StringBuilder message = new StringBuilder();
if (Cause == null)
message.Append("Error decoding XDR frame");
else
message.Append("Error decoding ").Append(Cause.Name);
if (Error != null)
message.Append(": ").Append(Error.Message);
return message.ToString();
}
}
}
}
|
8452bef5ff98a0a15511e1865b25196bc611449b
|
C#
|
a-n-n-i-e/CognitiveCustomVision-TrainFinderBot
|
/TrainFinderBot/Dialogs/RootDialog.cs
| 2.75
| 3
|
using System;
using System.Threading.Tasks;
using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Connector;
using Microsoft.Cognitive.CustomVision;
using System.Net.Http;
using Newtonsoft.Json;
using TrainFinderBot.Models;
namespace TrainFinderBot.Dialogs
{
[Serializable]
public class RootDialog : IDialog<object>
{
public Task StartAsync(IDialogContext context)
{
// デフォルトのメッセージをセット
context.PostAsync($"こんにちは！画像DE路線当てBot です。");
context.Wait(MessageReceivedAsync);
return Task.CompletedTask;
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
// 変数定義
string tag = ""; // 電車カテゴリータグ
string msg = ""; // 返答メッセージ
string lineName = ""; // [追加] 路線名 (駅すぱあと運航路線名)
string lineCode = ""; // [追加] 路線コード (駅すぱあと運航路線コード)
// Custom Vision API を使う準備
var cvCred = new PredictionEndpointCredentials("YOUR_PREDICTION_KEY");
var cvEp = new PredictionEndpoint(cvCred);
var cvGuid = new Guid("YOUR_PROJECT_ID");
// 画像が送られてきたら Custom Vision を呼び出してタグを取得
if (activity.Attachments?.Count != 0)
{
// 送られてきた画像を Stream として取得
var photoUrl = activity.Attachments[0].ContentUrl;
var client = new HttpClient();
var photoStream = await client.GetStreamAsync(photoUrl);
try
{
// 画像を判定
var cvResult = await cvEp.PredictImageAsync(cvGuid, photoStream);
// タグを取得
tag = cvResult.Predictions[0].Tag;
}
catch
{
// Error Handling
}
}
// メッセージをセット
if (tag != "")
{
//msg = tag + "、に いちばんにてるね！";
// タグに応じてメッセージをセット
switch (tag)
{
case "Chuo_Sobu":
lineName = "ＪＲ中央・総武線各駅停車";
lineCode = "110";
break;
case "Chuo_Ex":
lineName = "ＪＲ中央線快速";
lineCode = "109";
break;
case "Keihin-Tohoku":
lineName = "ＪＲ京浜東北線";
lineCode = "115";
break;
case "Tokaido":
lineName = "ＪＲ東海道本線";
lineCode = "117";
break;
case "Yamanote":
lineName = "ＪＲ山手線";
lineCode = "113";
break;
case "Yokosuka_SobuEx":
lineName = "ＪＲ横須賀線";
lineCode = "116";
break;
}
// 路線情報を取得してセット
var list = await GetStationList(lineCode); // ※GetStationList は次以降の項目で作成
msg = lineName + "、に いちばんにてるね！\n\n"
+ lineName + "は、以下のえきをはしるよ。\n\n---- - \n\n"
+ list;
}
else
{
// 判定できなかった場合
msg = "電車の写真を送ってね";
}
await context.PostAsync(msg);
context.Wait(MessageReceivedAsync);
}
private async Task<string> GetStationList(string lineCode)
{
var client = new HttpClient();
// 路線名、アクセスキーをセット
var ekiRequest = "http://api.ekispert.jp/v1/json/station?&operationLineCode="
+ lineCode
+ "&direction=down&key="
+ "YOUR_ACCESSKEY"; //アクセスキー
// 路線情報の取得
var ekiResult = await client.GetStringAsync(ekiRequest);
var ekiStr = Uri.UnescapeDataString(ekiResult.ToString());
var ekiModel = JsonConvert.DeserializeObject<StationModel>(ekiStr);
// 停車駅情報を編集
var stationList = "";
foreach (var point in ekiModel.ResultSet.Point)
{
stationList = stationList + "→" + point.Station.Name;
}
stationList = stationList.Substring(1);
return stationList;
}
}
}
|
011aacc66a3e01eaf87199feee23975c52df6c34
|
C#
|
velev1/HomeworkTA
|
/C#1/Loops/HexToDecimal/HexToDecimal.cs
| 3.625
| 4
|
//Using loops write a program that converts a hexadecimal integer number to its decimal form.
//The input is entered as string. The output should be a variable of type long.
//Do not use the built-in .NET functionality.
//Input
//The input will consists of a single line containing a single hexadecimal number as string.
//Output
//The output should consist of a single line - the decimal representation of the number as string.
//Constraints
//All numbers will be valid 64-bit integers.
//Time limit: 0.1s
//Memory limit: 16MB
//Sample tests
//Input Output
//FE 254
//1AE3 6883
//4ED528CBB4 338583669684
using System;
class HexToDecimal
{
static void Main()
{
string inputHex = Console.ReadLine();
int counter = 0;
long result = 0L;
for (int i = inputHex.Length - 1; i >= 0; i--)
{
switch (inputHex.Substring(i, 1))
{
case "A": result += (10 * (long)Math.Pow(16, counter)); break;
case "B": result += (11 * (long)Math.Pow(16, counter)); break;
case "C": result += (12 * (long)Math.Pow(16, counter)); break;
case "D": result += (13 * (long)Math.Pow(16, counter)); break;
case "E": result += (14 * (long)Math.Pow(16, counter)); break;
case "F": result += (15 * (long)Math.Pow(16, counter)); break;
default:
result += (Convert.ToInt64(inputHex.Substring(i, 1)) * (long)Math.Pow(16, counter));
break;
}
counter++;
}
Console.WriteLine(result.ToString());
}
}
|
7685be9e272d2d5dcd5f1646f5ddb2ea005e63c5
|
C#
|
AgmasGold/anno-designer
|
/AnnoDesigner/BrushCache.cs
| 2.90625
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;
using AnnoDesigner.model;
namespace AnnoDesigner.Helper
{
public class BrushCache : IBrushCache
{
private static Dictionary<Color, SolidColorBrush> _cachedBrushes;
static BrushCache()
{
_cachedBrushes = new Dictionary<Color, SolidColorBrush>();
}
public SolidColorBrush GetSolidBrush(Color color)
{
if (!_cachedBrushes.TryGetValue(color, out var foundBrush))
{
foundBrush = new SolidColorBrush(color);
if (foundBrush.CanFreeze)
{
foundBrush.Freeze();
}
_cachedBrushes.Add(color, foundBrush);
}
return foundBrush;
}
}
}
|
94fb17ab9a80affd61498a0d75a927990bb7cb38
|
C#
|
JakeBR72/Code-Examples
|
/CSE 3902 Mario Game/sprint3/Items/ItemObjects/OneUp.cs
| 2.53125
| 3
|
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MarioGame
{
public class OneUp : IItem
{
public bool ShouldUpdate { get; set; }
public Vector2 Location { get; set; }
public IPhysics Physics { get; set; }
public bool IsCollidable { get; set; }
public bool BeRemoved { get; set; }
public Rectangle DestinationRectangle
{
get { return Sprite.DestinationRectangle; }
set { Sprite.DestinationRectangle = value; }
}
private IItemSprite Sprite;
private bool beingProduced;
private bool goLeftAfterProduced;
private bool isBeingDrawn;
private int productionTimer;
public OneUp(Vector2 location)
{
Location = location;
Physics = new ItemPhysics(this);
Sprite = ItemSpriteFactory.Instance.CreateOneUp(location);
IsCollidable = true;
beingProduced = false;
isBeingDrawn = true;
BeRemoved = false;
productionTimer = 0;
}
public void DontDraw()
{
isBeingDrawn = false;
}
public void GetProduced(bool marioFacingLeft)
{
ItemBlockSoundBoard.Instance.PlayPowerUpAppear();
goLeftAfterProduced = marioFacingLeft;
beingProduced = true;
Physics.MaxPosition = new Vector2(PhysicsUtilites.XMaxPosition, (int)Location.Y - Sprite.getTextureHeight());
Physics.YVelocity = PhysicsUtilites.ItemProductionVelocity;
isBeingDrawn = true;
}
public void draw(SpriteBatch spriteBatch, Vector2 location)
{
if (isBeingDrawn)
{
Location = location;
Sprite.draw(spriteBatch, location);
}
}
public void update()
{
if (ShouldUpdate)
{
DestinationRectangle = Sprite.DestinationRectangle;
Sprite.update();
if (beingProduced && productionTimer % 3 == 0)
{
Physics.UpdatePosition();
CheckForEndOfBeingProduced();
}
else if (!beingProduced)
{
Physics.UpdatePosition();
}
}
}
private void CheckForEndOfBeingProduced()
{
if (Location.Y <= Physics.MaxPosition.Y)
{
Physics.YVelocity = 0;
Physics.GravityCoef = PhysicsUtilites.GlobalGravityCoef;
IsCollidable = true;
Physics.MaxPosition = new Vector2(PhysicsUtilites.XMaxPosition, PhysicsUtilites.YMaxPosition);
beingProduced = false;
if (goLeftAfterProduced)
{
Physics.XVelocity = Physics.XMinVelocity;
}
else
{
Physics.XVelocity = Physics.XMaxVelocity;
}
}
}
}
}
|
23588f3fa6e7f7c780b4548b18f76cc903fde3fd
|
C#
|
Petrakisos/TelerikAcademy
|
/CSharpPart2/04.NumeralSystems/03.DecimalToHexadecimal/DecimalToHexadecimal.cs
| 3.953125
| 4
|
using System;
class DecimalToHexadecimal
{
static string ConvertDecimalToHexadecimal(long decimalValue)
{
string sum = "";
string[] hexDigits = "0 1 2 3 4 5 6 7 8 9 A B C D E F".Split(' ');
int baseValue = 16;
do
{
long bit = decimalValue % baseValue;
sum = hexDigits[bit] + sum;
decimalValue /= baseValue;
}
while (decimalValue != 0);
return sum;
}
static void Main()
{
long N = long.Parse(Console.ReadLine());
Console.WriteLine(ConvertDecimalToHexadecimal(N));
}
}
|
19675487cd4f0168257c63210b711d972ec03f5f
|
C#
|
shendongnian/download4
|
/code6/1056478-27336074-146726206-6.cs
| 2.90625
| 3
|
public string ReadPage(string path, string method = "GET")
{
var request = (HttpWebRequest)WebRequest.Create(path);
request.Method = method;
request.Host = "somehost.de";
request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
request.Referer = @"http://somehost.de/login.php?redir=list.php%3Ftype%3Dmm";
request.AllowAutoRedirect = true;
request.Headers.Add("Cookie", LoginCookie);
using (var response = (HttpWebResponse)request.GetWEResponse())
using (var reader = new StreamReader(response.GetResponseStream()))
{
return reader.ReadToEnd();
}
}
|
4461d09cc29cc1c49417d2bcbf08f17f81f4c896
|
C#
|
solarwinds/OrionSDK
|
/Src/Contract/Serialization/XmlStrippedSerializerCache.cs
| 2.6875
| 3
|
// Important:
// This file has a copy that needs to be kept in sync:
// //depot/Dev/Main/Platform/InformationService/Src/InformationService/Core/Serialization/XmlStrippedSerializerCache.cs
using System;
using System.Collections.Generic;
using System.Xml.Serialization;
namespace SolarWinds.InformationService.Contract2.Serialization
{
/// <summary>
/// Since it is so expensive to construct serializers, this object caches them.
/// </summary>
internal class XmlStrippedSerializerCache
{
private readonly Dictionary<string, XmlStrippedSerializer> cache = new Dictionary<string, XmlStrippedSerializer>();
public XmlStrippedSerializer GetSerializer(Type type)
{
XmlStrippedSerializer strippedSerializer;
string typeName = type.FullName;
bool found;
lock (cache)
{
found = cache.TryGetValue(typeName, out strippedSerializer);
}
if (!found)
{
strippedSerializer = GetSerializerInternal(type, typeName);
}
return strippedSerializer;
}
private XmlStrippedSerializer GetSerializerInternal(Type type, string typeName)
{
XmlReflectionImporter xmlReflectionImporter = new XmlReflectionImporter();
XmlTypeMapping xmlTypeMapping = xmlReflectionImporter.ImportTypeMapping(type);
//Create the new serializer
XmlStrippedSerializer strippedSerializer = new XmlStrippedSerializer(new XmlSerializer(type), xmlTypeMapping.XsdElementName, xmlTypeMapping.Namespace, type);
lock (cache)
{
cache[typeName] = strippedSerializer;
}
return strippedSerializer;
}
}
}
|
2361c59dfef40397a2c7a74916781c30aee707c8
|
C#
|
SonicTheCat/ProgrammingBasics-SoftUni
|
/CSharpExamPrep/2016.November-20-Morning/02.Pets/Program.cs
| 3.5625
| 4
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _02.Pets
{
class Program
{
static void Main(string[] args)
{
int daysAway = int.Parse(Console.ReadLine());
int leftFoodInKg = int.Parse(Console.ReadLine());
double DogFoodKg = double.Parse(Console.ReadLine());
double CatFoodKg = double.Parse(Console.ReadLine());
double turtleFoodGr = double.Parse(Console.ReadLine());
double dogAte = DogFoodKg * daysAway;
double catAte = CatFoodKg * daysAway;
double turtleAte = (turtleFoodGr * daysAway)/1000;
double totalEaten = dogAte + catAte + turtleAte;
var result = Math.Abs(totalEaten - leftFoodInKg);
if (totalEaten<=leftFoodInKg)
Console.WriteLine($"{Math.Floor(result)} kilos of food left.");
else
Console.WriteLine($"{Math.Ceiling(result)} more kilos of food are needed.");
}
}
}
|
ab0b0e1ed6d3adfb3c91fee8952d2eae1f268b19
|
C#
|
soomker/Task8Searcher
|
/Searcher/SearchProvider.cs
| 2.8125
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;
using System.Reflection;
using Search;
using Searcher.OwnSectionRead;
namespace Searcher
{
class SearchProvider
{
private SearchProviderSection searchSection;
private string findTarget = String.Empty;
public SearchProvider(string targetSearch)
{
searchSection = (SearchProviderSection)ConfigurationManager.GetSection("SearchSection");
findTarget = targetSearch;
}
public void StartSearch()
{
string result = String.Empty;
for (int i = 0; i < searchSection.AssemblyColl.Count; i++)
{
if (!String.IsNullOrEmpty(result))
{
continue;
}
string asmName = searchSection.AssemblyColl[i].AssemblyName;
Assembly asm = Assembly.Load(asmName);
Type t = asm.GetType(searchSection.AssemblyColl[i].SearchClass);
object searchObject = t.GetConstructor(new Type[] { }).Invoke(new object[] { });
if (searchObject == null)
{
Console.WriteLine("Can't create a search object " + searchSection.AssemblyColl[i].SearchClass + " From Assembly" + searchSection.AssemblyColl[i].AssemblyName);
return;
}
try
{
result = (string)t.GetMethod("Search").Invoke(searchObject, new object[2] { findTarget, searchSection.AssemblyColl[i].Param });
}
catch (Exception)
{
Console.WriteLine("Can't call method Search. Maybe "+ searchSection.AssemblyColl[i].SearchClass + " don't support a ISearch interface ");
continue;
}
}
if (String.IsNullOrEmpty(result))
{
result = "Couldn't find it anywhere :(";
}
Console.WriteLine(result);
}
}
}
|
9226e324c1771e258ab6b23715b62c2ee394e4e3
|
C#
|
mohdnat91/Titan_old
|
/Titan/Resolution/PropertyResolutionHandler.cs
| 2.546875
| 3
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;
using Titan.Utilities;
namespace Titan.Resolution
{
internal class PropertyResolutionHandler : IResolutionHandler
{
public ResolutionInfo Handle(ResolutionRequest request)
{
ResolutionInfo info = request.Conventions.GetDefaultResolution(request);
XmlElementAttribute element = request.GetAttribute<XmlElementAttribute>();
if (element != null)
{
info.NodeType = XmlNodeType.Element;
if(!string.IsNullOrWhiteSpace(element.ElementName)) info.Predicate = (x => x.GetName() == element.ElementName);
}
XmlAttributeAttribute attribute = request.GetAttribute<XmlAttributeAttribute>();
if (attribute != null)
{
info.NodeType = XmlNodeType.Attribute;
if(!string.IsNullOrWhiteSpace(attribute.AttributeName)) info.Predicate = (x => x.GetName() == attribute.AttributeName);
}
return info;
}
}
}
|