static async Task Main(string[] args)
{
//Task1
Calculations calc = new Calculations();
calc.ShowResult += calc.ResultInf;
Thread first = new Thread(new ThreadStart(calc.Integral))
{
Priority = ThreadPriority.Highest
};
Thread second = new Thread(new ThreadStart(calc.Integral))
{
Priority = ThreadPriority.Lowest
};
first.Start();
second.Start();
//Task2
MemoryStream stream = new MemoryStream();
StreamService service = new StreamService();
var firstMethod = service.WriteToStream(stream);
var secondMethod = service.CopyFromStream(stream, "ote.txt");
//await Task.WhenAll(firstMethod, secondMethod);
Task.WaitAll(firstMethod, secondMethod);
Func <LearningCourse, bool> checking = LearningCourse.Checks;
await service.GetStatisticsAsync("ote.txt", checking);
}
public static string ParseId(string url, out StreamService service)
{
Uri uri = new Uri(url);
if (uri.Host.Contains("twitch.tv"))
{
service = StreamService.Twitch;
}
else if (uri.Host.Contains("hitbox.tv") || uri.Host.Contains("smashcast.tv"))
{
service = StreamService.Hitbox;
}
else if (uri.Host.Contains("youtube.com"))
{
service = StreamService.Youtube;
}
else
{
throw new FormatException();
}
switch (service)
{
case StreamService.Twitch:
return(uri.Segments[uri.Segments.Length - 2].Trim('/') + uri.Segments.Last());
case StreamService.Hitbox:
return(uri.Segments.Last());
case StreamService.Youtube:
return(Util.GetParameterFromUri(uri, "v"));
}
throw new FormatException();
}
private static async void OnChanged(object source, FileSystemEventArgs e)
{
if (File.Exists(Path.Combine(processed, e.Name)))
{
Console.WriteLine($"File {e.Name} has alredy been processed!");
return;
}
await Task.Delay(200);
countDown.AddCount();
await ProcessSalesContent(e.FullPath);
countDown.Decrement();
if (countDown.CurrentCount == 0)
{
var report = new SalesReportFormatting().Format(new SalesAnalises().Report());
await StreamService.WriteReport("./data/out/SalesReport.txt", report);
Console.WriteLine(report);
Console.WriteLine("SalesReport saved in data/out directory");
Console.WriteLine("Press 'q' to quit the sample.");
}
}
public Task Invoke(HttpContext context)
{
var environmentService = (EnvironmentService)context.RequestServices.GetService(typeof(EnvironmentService));
var request = context.Request;
var uri = request.GetUri();
var path = uri.PathAndQuery;
Directory.CreateDirectory(environmentService.ReplayLogFolder);
var thisPort = uri.Port;
var yamahaPort = MapPortToReal(uri);
var body = "<not decoded>";
if (!uri.ToString().Contains("secure") && request.Method.ToLower() == "post")
{
body = StreamService.ReadText(request.Body);
}
var lineContent = $"{DateTime.Now.ToString("hh:mm:ss.ff")},{thisPort},{yamahaPort},{request.Method},{path},{body},{Environment.NewLine}";
lock (_lockObject)
{
File.AppendAllText(environmentService.ActivityLogFilename, lineContent);
}
return(next(context));
}
private static async Task ProcessSalesContent(string fileFullPath)
{
try
{
var fileInfo = new FileInfo(fileFullPath);
var salesAnalises = new SalesAnalises();
Console.WriteLine($"Reading content of {fileInfo.Name}");
await StreamService.LoadLinesOf(fileFullPath, (task) =>
{
Console.WriteLine(task.Result);
var notifications = salesAnalises.Process(task.Result);
if (notifications.HasMessages)
{
notifications.Items.ToList().ForEach(Console.WriteLine);
}
});
salesAnalises.SaveChanges();
File.Copy(fileFullPath, Path.Combine(processed, fileInfo.Name));
File.Delete(fileFullPath);
Console.WriteLine($"File {fileInfo.Name} has been processed with success!");
}
catch (Exception ex) { Console.WriteLine(ex.Message); }
}
/// <summary>
/// Creates a new stream to the specified device and initializes the specified service.
/// </summary>
/// <param name="deviceId">The device to connect to.</param>
/// <param name="service">The service to initialize.</param>
/// <param name="serviceParameters">Optional initialization parameters for the service.</param>
/// <returns>The newly created stream.</returns>
public Task <DeviceStream> CreateStreamAsync(string deviceId, StreamService service, string serviceParameters = null)
{
return(Task.Run(() =>
{
return CreateStream(deviceId, service, serviceParameters);
}));
}
public async Task OpenAndReadFileFromStreamAsync()
{
#region [ -- Setting up mock service(s) -- ]
var openFileInvoked = false;
var streamService = new StreamService
{
OpenFileAction = (path) =>
{
Assert.Equal(
AppDomain.CurrentDomain.BaseDirectory.Replace("\\", "/").TrimEnd('/') + "/foo",
path);
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write("foo bar");
writer.Flush();
stream.Flush();
stream.Position = 0;
openFileInvoked = true;
return(stream);
}
};
#endregion
var lambda = await Common.EvaluateAsync(@"
io.stream.open-file:foo
io.stream.read:x:@io.stream.open-file
convert:x:-
type:string
", null, null, streamService);
Assert.True(openFileInvoked);
Assert.Equal("foo bar", lambda.Children.Skip(2).First().Value);
}
public StreamKontrolUnitHub(StreamService streamService, FollowerClient followerClient, StreamKontrolUnitClient streamKontrolUnitClient, ViewerClient viewerClient)
{
this.StreamService = streamService;
this.StreamKontrolUnitClient = streamKontrolUnitClient;
this.FollowerClient = followerClient;
this.ViewerClient = viewerClient;
StreamService.Updated += StreamService_Updated;
}
public void Handle(SystemMessage.SystemInit message)
{
_server = new Server {
Services = { StreamService.BindService(new RxStreamService(_publisher)) },
Ports = { _serverPort }
};
Log.Info("Initialized gRpc server");
}
public MusicController(ILogger <MusicController> logger,
ArtistService artistService,
StreamService streamService)
{
_logger = logger;
_artistService = artistService;
_streamService = streamService;
}
public FollowerHub(
StreamService streamService,
FollowerClient client
)
{
this.StreamService = streamService;
this.FollowerClient = client;
StreamService.Updated += StreamService_Updated;
}
public TutorStream(StorageService storage, CookieService cookie, StreamService stream, NotificationService notification, EncryptionService encryption, ScheduleService schedule, EmailService email)
{
storageService = storage;
cookieService = cookie;
streamService = stream;
notificationService = notification;
encryptionService = encryption;
scheduleService = schedule;
emailService = email;
}
async Task AudioControl()
{
PlayCount++;
if (PlayCount > 1)
{
try
{
AppDelegate.MediaPlayer.StopPlayback();
PlayCount = 0;
}
catch (Exception ex)
{
Console.WriteLine($"error:{ex.Message}");
}
try
{
StartStopButton.SetTitle("Play", UIControlState.Normal);
StartStopButton.SetImage(UIImage.FromBundle("play-fill.png"), UIControlState.Normal);
Console.WriteLine("clicked");
}
catch (Exception ex)
{
}
}
else
{
try
{
await StreamService.GetStreamUrlAsync();
await AppDelegate.MediaPlayer.Initialize();
}
catch (Exception ex)
{
Console.WriteLine($"error:{ex.Message}");
}
try
{
StartStopButton.SetTitle("", UIControlState.Normal);
StartStopButton.SetImage(null, UIControlState.Normal);
var AI = new UIActivityIndicatorView(UIActivityIndicatorViewStyle.White);
StartStopButton.AddSubview(AI);
AI.Center = new CGPoint(StartStopButton.Frame.Size.Width / 2, StartStopButton.Frame.Size.Height / 2);
AI.StartAnimating();
await Task.Delay(3000);
AI.StopAnimating();
StartStopButton.SetTitle("Stop", UIControlState.Normal);
StartStopButton.SetImage(UIImage.FromBundle("stop-fill.png"), UIControlState.Normal);
}
catch (Exception ex)
{
}
}
}
public JobService(DiscordSocketClient client, DatabaseContext database, LeaderboardService leaderboard, LogService log, RssService rss, StreamService stream)
{
_client = client;
_database = database;
_leaderboard = leaderboard;
_log = log;
_rss = rss;
_stream = stream;
JobManager.Initialize();
}
internal static DeviceStream Create(DeviceConnection owner, StreamService service, string serviceParameters = null)
{
if (serviceParameters != null)
{
return(Create(owner, serviceIdentifiers[service] + " " + serviceParameters));
}
else
{
return(Create(owner, serviceIdentifiers[service]));
}
}
public async Task ExecuteResultAsync(ActionContext context)
{
var response = context.HttpContext.Response;
response.ContentType = "text/xml";
var xml = GetXml();
response.ContentLength = xml.Length;
using (var stream = StreamService.FromString(xml))
{
await stream.CopyToAsync(context.HttpContext.Response.Body);
}
}
public FollowersController(
StreamService streamService,
IOptions <FollowerGoalConfiguration> config,
IHostingEnvironment env,
FollowerClient followerClient)
{
this.StreamService = streamService;
this.Configuration = config.Value;
this.HostingEnvironment = env;
this.FollowerClient = followerClient;
}
public ArtistController(ILogger <ArtistController> logger,
ArtistService artistService,
AuthService authService,
TagService tagService,
StreamService streamService,
ImageService imageService)
{
_logger = logger;
_artistService = artistService;
_authService = authService;
_tagService = tagService;
_streamService = streamService;
_imageService = imageService;
}
public static void Main(string[] args)
{
var server = new GrpcServer
{
Services = { StreamService.BindService(new QueryService()) },
Ports = { new ServerPort("127.0.0.1", Port, ServerCredentials.Insecure) }
};
server.Start();
Console.WriteLine("Grpc server listening on port " + Port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
}
public async Task OpenAndSaveFileFromStreamAsync()
{
#region [ -- Setting up mock service(s) -- ]
var saveInvoked = false;
var openFileInvoked = false;
var streamService = new StreamService
{
SaveFileActionAsync = (stream, path) =>
{
Assert.Equal(
AppDomain.CurrentDomain.BaseDirectory.Replace("\\", "/").TrimEnd('/') + "/bar",
path);
Assert.True(stream.Length > 0);
var reader = new StreamReader(stream);
var content = reader.ReadToEnd();
Assert.Equal("foo bar", content);
saveInvoked = true;
},
OpenFileAction = (path) =>
{
Assert.Equal(
AppDomain.CurrentDomain.BaseDirectory.Replace("\\", "/").TrimEnd('/') + "/foo",
path);
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write("foo bar");
writer.Flush();
stream.Flush();
stream.Position = 0;
openFileInvoked = true;
return(stream);
}
};
#endregion
var lambda = await Common.EvaluateAsync(@"
io.stream.open-file:foo
io.stream.save-file:bar
get-value:x:@io.stream.open-file
", null, null, streamService);
Assert.True(saveInvoked);
Assert.True(openFileInvoked);
}
public CreateAndEnqueueJobReturnValue CreateAndEnqueueJob(StreamService service, string id, IVideoInfo info = null)
{
IVideoJob job;
switch (service)
{
case StreamService.Twitch:
job = new TwitchVideoJob(id);
break;
case StreamService.TwitchChatReplay:
job = new TwitchChatReplayJob(id);
break;
case StreamService.Hitbox:
job = new HitboxVideoJob(id);
break;
case StreamService.Youtube:
job = new YoutubeVideoJob(id);
break;
case StreamService.RawUrl:
job = new GenericFileJob(id);
break;
case StreamService.FFMpegJob:
job = new FFMpegReencodeJob(id);
break;
default:
throw new Exception(service.ToString() + " isn't a known service.");
}
if (info != null)
{
job.VideoInfo = info;
}
bool success = EnqueueJob(job);
return(new CreateAndEnqueueJobReturnValue {
Success = success, Job = job
});
}
static async Task Main(string[] args)
{
//Первое задание
object first = "высокий приоритет";
object second = "низкий приоритет";
Integrate integrate = new Integrate();
integrate.Finish += integrate.Result;
Thread threadFirst = new Thread(integrate.Integration);
threadFirst.Priority = ThreadPriority.Highest;
Thread threadSecond = new Thread(integrate.Integration);
threadSecond.Priority = ThreadPriority.Lowest;
threadFirst.Start(first);
threadSecond.Start(second);
Console.ReadKey();
//Второе задание
using (MemoryStream stream = new MemoryStream())
{
StreamService service = new StreamService();
Func <Worker, bool> retFunc = Filter;
Task writeToStream = service.WriteToStream(stream);
await Task.Delay(100);
Task copyFromStream = service.CopyFromStream(stream, "Test.txt");
await Task.WhenAll(new Task[] { writeToStream, copyFromStream });
Console.WriteLine("=============================================");
Task <int> stat = Task.Run(() => service.GetStatisticsAsync("Test.txt", retFunc));
Console.WriteLine($"\nКоличество объектов, удовлетворяющих условию: {stat.Result}");
}
}
public static void Init()
{
try
{
byte[] syntaxDefPath = Properties.Resources.Assembly;
s_SyntaxFilePath = StreamService.WriteToTemporaryFile(syntaxDefPath);
// this expects a directory for a path. not the actual file?
string syntaxFileDir = Path.GetDirectoryName(s_SyntaxFilePath);
var fsm = new FileSyntaxModeProvider(syntaxFileDir);
HighlightingManager.Manager.AddSyntaxModeFileProvider(fsm);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
Console.WriteLine("Stack trace:\n" + ex.StackTrace);
MessageBox.Show("Failed to load syntax file for highlighting. Keyword highlighting will be disabled!",
"File Editor Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void buttonDownload_Click(object sender, EventArgs e)
{
string unparsedId = textboxMediaId.Text.Trim();
if (unparsedId == "")
{
return;
}
StreamService service = StreamService.Unknown;
string id;
if (unparsedId.Contains('/'))
{
try {
id = ParseId(unparsedId, out service);
} catch (Exception) {
MessageBox.Show("Can't determine service and/or video ID of " + unparsedId);
return;
}
}
else
{
id = unparsedId;
}
if (comboBoxService.Text != "Autodetect")
{
service = GetServiceFromString(comboBoxService.Text);
}
else if (service == StreamService.Unknown)
{
MessageBox.Show("Can't autodetect service without URL!");
return;
}
CreateAndEnqueueJob(service, id);
textboxMediaId.Text = "";
}
protected override async Task OnParametersSetAsync()
{
if (string.IsNullOrWhiteSpace(Id))
{
LoadingStateStreamSource = LoadingContainerState.Error;
return;
}
LoadingStateStreamSource = LoadingContainerState.Loading;
try
{
StreamResponses = await StreamService.GetStream(Id);
if (StreamResponses is not null && StreamResponses.Any())
{
LoadingStateStreamSource = LoadingContainerState.Loaded;
}
else
{
LoadingStateStreamSource = LoadingContainerState.Empty;
}
}
public Repository()
{
Console.Title = "Repository Server";
using (host = StreamService.CreateHostServiceChannel("http://localhost:8000/StreamService"))
{
while (true)
{
try
{
host.Open();
Console.WriteLine("Start file transfer service at host Repository (http://localhost:8000/StreamService)\n***********************************");
break;
}
catch (Exception ex)
{
Console.WriteLine("\nexecption when oepn service on host:", ex.Message);
Thread.Sleep(1000);
}
}
while (true)
{
}
}// disposal host
}
/// <summary>Dispose services. </summary>
public void Dispose()
{
if (ScriptingService != null)
{
ScriptingService.Dispose();
}
if (ExprDeclaredService != null)
{
ExprDeclaredService.Dispose();
}
if (DataFlowService != null)
{
DataFlowService.Dispose();
}
if (VariableService != null)
{
VariableService.Dispose();
}
if (MetricsReportingService != null)
{
MetricsReportingService.Dispose();
}
if (ThreadingService != null)
{
ThreadingService.Dispose();
}
if (StatementLifecycleSvc != null)
{
StatementLifecycleSvc.Dispose();
}
if (FilterService != null)
{
FilterService.Dispose();
}
if (SchedulingService != null)
{
SchedulingService.Dispose();
}
if (SchedulingMgmtService != null)
{
SchedulingMgmtService.Dispose();
}
if (StreamService != null)
{
StreamService.Destroy();
}
if (NamedWindowMgmtService != null)
{
NamedWindowMgmtService.Dispose();
}
if (NamedWindowDispatchService != null)
{
NamedWindowDispatchService.Dispose();
}
if (EngineLevelExtensionServicesContext != null)
{
EngineLevelExtensionServicesContext.Dispose();
}
if (StatementIsolationService != null)
{
StatementIsolationService.Dispose();
}
if (DeploymentStateService != null)
{
DeploymentStateService.Dispose();
}
}
public bool JobExists( StreamService service, string id ) {
foreach ( var item in objectListViewDownloads.Items ) {
IVideoJob job = ( item as BrightIdeasSoftware.OLVListItem )?.RowObject as IVideoJob;
if ( job != null && job.VideoInfo.Service == service && job.VideoInfo.VideoId == id ) {
return true;
}
}
return false;
}
public bool CreateAndEnqueueJob( StreamService service, string id, IVideoInfo info = null ) {
IVideoJob job;
switch ( service ) {
case StreamService.Twitch:
job = new TwitchVideoJob( TwitchAPI, id );
break;
case StreamService.Hitbox:
job = new HitboxVideoJob( id );
break;
default:
throw new Exception( service.ToString() + " isn't a known service." );
}
if ( info != null ) {
job.VideoInfo = info;
}
return EnqueueJob( job );
}
public static string ParseId( string url, out StreamService service ) {
Uri uri = new Uri( url );
if ( uri.Host.Contains( "twitch.tv" ) ) {
service = StreamService.Twitch;
} else if ( uri.Host.Contains( "hitbox.tv" ) ) {
service = StreamService.Hitbox;
} else {
throw new FormatException();
}
switch ( service ) {
case StreamService.Twitch:
return uri.Segments[uri.Segments.Length - 2].Trim( '/' ) + uri.Segments.Last();
case StreamService.Hitbox:
return uri.Segments.Last();
}
throw new FormatException();
}
/// <summary>
/// The iOS app POSTs the data application/formurlencoded and not application/json which basically stuffs model binding
/// </summary>
public string ReadBody()
{
return(StreamService.ReadText(Request.Body));
}
public static void StopServer()
{
ZyanConnection.Dispose();
ZyanHost.Dispose();
StreamService.DeleteTempFiles();
}
public CurrentViewersModel(
StreamService streamService
)
{
this.StreamService = streamService;
}
