Next add a line / lines Debugger.Break(); in your code where you want the debugger to start. Now compile in debug mode clicking in Visual Studio menu: Build, Build Solution while the Configuration Manager is set to Debug.
After the application compiled successfully we can stop and start the service to ensure these modifications are run:
Right click the Visual Studio application and select more…, Run as administrator
Click Debug, Attach to Process in the Visual Studio menu.
This will open a dialog where you need to select the right process to debug. Check the Show processes from all users checkbox. Find your Service process and click Attach.
After you have written your Windows Service in Visual Studio you might want to run this to test and use the service.
You can run your service with a few simple steps: I used a service called ServiceName in the following examples.
First start a command prompt: cmd (as admin)
Install a service is done using sc create, syntax: sc create ServiceName binPath=”pathto.exe”. If the command was successfull it will report SUCCESS. Example:
Install a service is done using sc create, syntax:
sc create ServiceName binPath=”pathto.exe”.
If the command was successfull it will report SUCCESS. Example:
I needed to
create a network share on Windows server machine which would require no
authentication whatsoever from users. This post is intended to serve me as a
reminder, since googling the solution every time eats easily away hours.
Settings
which need to be changed of course depend on version of Windows of network
share host. This post describes how to do it on a Windows 2012 R2.
Roughly what needs to be done is:
network
share should be created
share permissions
need to be set
security
settings need to be changed
In more detail:
Share a
folder by opening folder properties, navigating to Sharing tab and clicking
Advanced Sharing…
Enable sharing and click Permissions
Add Everyone (should already be there), Guest and ANONYMOUS LOGON and give them Read access
Open Group
Policy Editor (hit Ctrl+R, type gpedit.msc and hit enter)
Navigate to Computer Configuration → Windows Settings → Security Settings → Local Policies → Security Options
Change
following:
Accounts:
Guest account status – change to Enabled
Network
access: Let Everyone permissions apply to anonymous users – change to Enabled
Network
access: Restrict anonymous access to Named Pipes and Shares – change to
Disabled
Network
access: Shares that can be accessed anonymously – enter name of share you
created in the text field
————
Then after this I still had no access. After further investigation I made the following 2 additional changes:
1 I removed “guest” account from “Deny access to this computer from the network”
2 I removed a cached password on the client computer in “control userpasswords2”
Nearly every VCS has some form of branching support. Branching means you
diverge from the main line of development and continue to do work without
messing with that main line. In many VCS tools, this is a somewhat expensive
process, often requiring you to create a new copy of your source code
directory, which can take a long time for large projects.
Some people refer to Git’s branching model as its “killer feature,” and it
certainly sets Git apart in the VCS community. Why is it so special? The way
Git branches is incredibly lightweight, making branching operations nearly
instantaneous, and switching back and forth between branches generally just as
fast. Unlike many other VCSs, Git encourages workflows that branch and merge
often, even multiple times in a day. Understanding and mastering this feature
gives you a powerful and unique tool and can entirely change the way that you
develop.
Branches in a Nutshell
To really understand the way Git does branching, we need to take a step
back and examine how Git stores its data.
As you may remember from Getting Started, Git doesn’t store data as a series of changesets or differences, but instead as a series of snapshots.
When you make a commit, Git stores a commit object that contains a pointer
to the snapshot of the content you staged. This object also contains the
author’s name and email address, the message that you typed, and pointers to
the commit or commits that directly came before this commit (its parent or
parents): zero parents for the initial commit, one parent for a normal commit,
and multiple parents for a commit that results from a merge of two or more
branches.
To visualize this, let’s assume that you have a directory containing three files, and you stage them all and commit. Staging the files computes a checksum for each one (the SHA-1 hash we mentioned in Getting Started), stores that version of the file in the Git repository (Git refers to them as blobs), and adds that checksum to the staging area:
$ git add
README test.rb LICENSE
$ git commit -m
‘The initial commit of my project’
When you create the commit by running git commit, Git checksums
each subdirectory (in this case, just the root project directory) and stores
those tree objects in the Git repository. Git then creates a commit object that
has the metadata and a pointer to the root project tree so it can re-create
that snapshot when needed.
Your Git repository now contains five objects: three blobs (each
representing the contents of one of the three files), one tree that
lists the contents of the directory and specifies which file names are stored
as which blobs, and one commit with the pointer to that root tree and
all the commit metadata.
Figure 9. A commit and its tree
If you make some changes and commit again, the next commit stores a pointer
to the commit that came immediately before it.
Figure 10. Commits and their parents
A branch in Git is simply a lightweight movable pointer to one of these
commits. The default branch name in Git is master. As you start
making commits, you’re given a master branch that points to the last
commit you made. Every time you commit, the master branch pointer
moves forward automatically.
Note
The “master” branch in Git is not a special
branch. It is exactly like any other branch. The only reason nearly every
repository has one is that the git init command creates it by default and most people don’t bother to change it.
Figure 11. A branch and its commit history
Creating a New Branch
What happens when you create a new branch? Well, doing so creates a new
pointer for you to move around. Let’s say you want to create a new branch
called testing. You do this with the git branch command:
$ git branch
testing
This creates a new pointer to the same commit you’re currently on.
Figure 12. Two branches pointing into the same series of commits
How does Git know what branch you’re currently on? It keeps a special
pointer called HEAD. Note that this is a lot different than the concept of HEAD in other VCSs
you may be used to, such as Subversion or CVS. In Git, this is a pointer to the
local branch you’re currently on. In this case, you’re still on master. The git branch command only created
a new branch — it didn’t switch to that branch.
Figure 13. HEAD pointing to a branch
You can easily see this by running a simple git log command that
shows you where the branch pointers are pointing. This option is called –decorate.
$ git log
–oneline –decorate
f30ab (HEAD
-> master, testing) add feature #32 – ability to add new formats to the
central interface
34ac2 Fixed bug
#1328 – stack overflow under certain conditions
98ca9 The
initial commit of my project
You can see the “master” and “testing” branches that are right there next
to the f30ab commit.
Switching Branches
To switch to an existing branch, you run the git checkout command. Let’s
switch to the new testing branch:
$ git checkout
testing
This moves HEAD to point to the testing branch.
Figure 14. HEAD points to the current branch
What is the significance of that? Well, let’s do another commit:
$ vim test.rb
$ git commit -a
-m ‘made a change’
Figure 15. The HEAD branch moves forward when a commit is made
This is interesting, because now your testing branch has
moved forward, but your master branch still points to the
commit you were on when you ran git checkout to switch branches. Let’s switch
back to the master branch:
$ git checkout
master
Figure 16. HEAD moves when you checkout
That command did two things. It moved the HEAD pointer back to point to the
master branch, and it reverted the files in your working directory back to the
snapshot that master points to. This also means the changes you make from this point forward
will diverge from an older version of the project. It essentially rewinds the
work you’ve done in your testing branch so you can go in a
different direction.
Note
Switching branches changes files in your working directory
It’s important to note that when you switch
branches in Git, files in your working directory will change. If you switch
to an older branch, your working directory will be reverted to look like it
did the last time you committed on that branch. If Git cannot do it cleanly,
it will not let you switch at all.
Let’s make a few changes and commit again:
$ vim test.rb
$ git commit -a
-m ‘made other changes’
Now your project history has diverged (see Divergent history). You created and switched to a branch, did some work on it, and then switched back to your main branch and did other work. Both of those changes are isolated in separate branches: you can switch back and forth between the branches and merge them together when you’re ready. And you did all that with simple branch, checkout, and commit commands.
Figure 17. Divergent history
You can also see this easily with the git log command. If
you run git log –oneline –decorate –graph –all it will print
out the history of your commits, showing where your branch pointers are and how
your history has diverged.
$ git log
–oneline –decorate –graph –all
* c2b9e (HEAD,
master) made other changes
| * 87ab2
(testing) made a change
|/
* f30ab add
feature #32 – ability to add new formats to the
* 34ac2 fixed
bug #1328 – stack overflow under certain conditions
* 98ca9 initial
commit of my project
Because a branch in Git is actually a simple file that contains the 40
character SHA-1 checksum of the commit it points to, branches are cheap to
create and destroy. Creating a new branch is as quick and simple as writing 41
bytes to a file (40 characters and a newline).
This is in sharp contrast to the way most older VCS tools branch, which
involves copying all of the project’s files into a second directory. This can
take several seconds or even minutes, depending on the size of the project,
whereas in Git the process is always instantaneous. Also, because we’re
recording the parents when we commit, finding a proper merge base for merging
is automatically done for us and is generally very easy to do. These features
help encourage developers to create and use branches often.
R
In Visual Studio it is really simple to add unit tests that are automatically run in your build script. Right click your solution to add a test project:
/// <summary> /// Test if flipcoins throws as many times as requested /// </summary> [TestMethod()] public void FlipCoinsTest1Times() { //Arrange int odd, even; int times = 1;
//Act CoinFlipper coinFlipper = new CoinFlipper(); coinFlipper.FlipCoins(times, out odd, out even); //Assert Assert.IsTrue(times == odd + even); }
Open Test explorer window
Right click a selection of tests and select “Run selected tests”.
When the tests are OK, we can check in the solution. Default the Build in Azure will run libraries with names containing *test*.
I was planning a migration for my solution from a build on my local machine to a build in Azure Devops. I want to use the Hosted VS2017 because then I do not have to worry about maintaining local Build servers.
When I added the solution to Azure and set up a build pipeline I encountered the following errors in the MSBuild log:
2019-01-10T10:11:49.9382855Z ##[error]Notepad\CrystalReportsViewer.cs(8,7): Error CS0246: The type or namespace name ‘CrystalDecisions’ could not be found (are you missing a using directive or an assembly reference?)
2019-01-10T10:11:49.9412999Z ##[error]Notepad\CrystalReport1.cs(153,53): Error CS0246: The type or namespace name ‘RequestContext’ could not be found (are you missing a using directive or an assembly reference?)
2019-01-10T10:11:49.9414407Z ##[error]Notepad\CrystalReportsViewer.cs(14,16): Error CS0246: The type or namespace name ‘ReportDocument’ could not be found (are you missing a using directive or an assembly reference?)
2019-01-10T10:11:49.9415960Z ##[error]Notepad\CrystalReport1.cs(19,35): Error CS0246: The type or namespace name ‘ReportClass’ could not be found (are you missing a using directive or an assembly reference?)
2019-01-10T10:11:49.9430403Z ##[error]Notepad\CrystalReport1.cs(24,32): Error CS0115: ‘CrystalReport1.ResourceName’: no suitable method found to override
2019-01-10T10:11:49.9432260Z ##[error]Notepad\CrystalReport1.cs(33,30): Error CS0115: ‘CrystalReport1.NewGenerator’: no suitable method found to override
2019-01-10T10:11:49.9433304Z ##[error]Notepad\CrystalReport1.cs(42,32): Error CS0115: ‘CrystalReport1.FullResourceName’: no suitable method found to override
I found a solution for this issue adding a pre-build event:
First I needed to add the CRRuntime msi and a pre-build.bat file to my solution:
The content for the pre-build file is an administrator installation of the CRRuntime msi. The command is: msiexec /a “%1CRRuntime_64bit_13_0_23.msi” /quiet /norestart /log “%1CRRuntime_64bit_13_0_23_install.log”. I only want this to be installed when building a release (in Azure). For this I added the condition to only install for release builds.
Goto Pipelines in your Azure Devops project and click on new pipeline. My example uses a project named WPFDatasetWithSQL.
*Important note: This solution will only work when you do NOT have a .gitignore file in your repository*
Click continue and choose .Net Desktop and click Apply.
If you want
to build the solution using a hosted machine keep the “Agent pool” set on
“Hosted VS2017”. If you need local components to build you could choose to use
a local machine or set up the required components in this build script.
For this
example I have no need for extra components and I will keep the Agent pool on
Hosted VS2017.
We are going
to change a few setps in this script:
1 Set the
MSBuild Arguments to /target:publish. This changes the MSBuild to add a
app.publish to the build directory for click once deployment.
2 Change the step Copy Files to add the app.publish folder to the artifacts folder. Display name = Copy Files to: $(build.artifactstagingdirectory) Source Folder = $(Build.SourcesDirectory)\src\BLM\bin\$(BuildConfiguration)\app.publish Contents = **\**
3 Change the artifact name. Display name = Publish Artifact: $(System.TeamProject)-$(Build.BuildNumber) Artifact name = $(System.TeamProject)-$(Build.BuildNumber)
Click Save and keep the default name.
Set up a release pipeline
Now we will
set up a release pipeline in which we can control and manage releases for this
application.
Click on Releases in the menu and click New pipeline.
Choose a Empty job template. The release pipeline is going to contain not much more than a few copy tasks.
For
starters we will have to choose an artifact. Choice is simple, we are going to
use the artifacts from the build pipeline. Select the Source Build pipeline set
up in the previous step and finish this by clicking the Add button below.
Next step in this release pipeline is a deployment to “Test”. For this purpose we will rename the default “Stage 1” to “Test”. For this, clicking the Stage1 image (not on the link to job with task) will open a properties window. Rename Stage1 to Test and click save right top in the corner.
Now
click the link to job and task in the Test stage. Click the agent job and
change the agent pool to the pool where you added the local agent. In my
example I added the local agent to a pool named “local machine”.
Now we will
add a job to copy the publish folder to a local directory. Click on the puls
sign next to “Agent job” and search for “Copy Files”
Select The task added below Job agent and fill in the details:
Select The task added below Job agent and fill in the details:
Display name = Copy Files to: c:\drop\$(System.TeamProject)\$(Release.EnvironmentName)\$(Release.ReleaseName)\
Source Folder = $(system.defaultworkingdirectory)_WPFDatasetWithSQL-.NET Desktop-CI * This last directory name is the build pipeline name
Target Folder = c:\drop\$(System.TeamProject)\$(Release.EnvironmentName)\$(Release.ReleaseName)\
The source
folder will contain the pipeline name for the build pipeline preceded by an
underscore:
Click save
in top right hand corner.
Now we are
going to add the production stage and the required copy jobs for this stage.
Click on
releases in the left menu and click edit.
Click “Clone” in Test stage. And rename this new stage “Copy of Test” to “Production”. Click the task details and here I added System.TeamProject to the source folder name. This removes the build number from the destination name.
Next click the plus sign for the “Agent job” to add a command line script. With this command line we will first clean the install folder before we copy the new release in that location. The command line script is rd /S /Q c:\drop\$(System.TeamProject)\Install\
Last task for this job is to add a second “Copy Files” task. This task will copy the publish content in the install folder.
For the first run disable the Command line script because the folder will not yet exist. This will cause an error if the command is executed while the directory does not exist. After the first run the command can be enabled.
Last
option is to add an approval trigger on production. A test manager or a group
of testers can be allowed to approve the release after testing.
Another nice feature is to enable continuous integration and continuous deployment in Azure. For this go to the build pipeline and click the checkbox for “Enable continuous integration” in the tab “Triggers”.
Second, go to release pipeline click the continuous deployment trigger and enable continuous deployment every time a new build is available. Click save.
First two times the deployment failed. I checked the logging and fixed some typing errors.
After approving the release the install folder will be updated with the required binaries.
When you open a copy of project files from a remote location / downloaded from the internet you get the message that the project location is not trusted:
or a security warning when opening the project warning that the project file may have come from a location that is not fully trusted:
First assure yourself that the files you downloaded are from a trustworthy source. If this is the case then you could remove the warnings from these files like this:
Unblock downloaded files in folder including subfolders:
gci -path “C:\BeeHive” -recurse | Unblock-File (replace “C:\BeeHive” with the folder in which you want to unblock all files)
private async void button1_Click(object sender, EventArgs e)
{
// Call the method that runs asynchronously.
string result = await WaitAsynchronouslyAsync();
// Call the method that runs synchronously.
//string result = await WaitSynchronously ();
// Display the result.
textBox1.Text += result;
}
// The following method runs asynchronously. The UI thread is not
// blocked during the delay. You can move or resize the Form1 window
// while Task.Delay is running.
public async Task<string> WaitAsynchronouslyAsync()
{
await Task.Delay(10000);
return “Finished”;
}
// The following method runs synchronously, despite the use of async.
// You cannot move or resize the Form1 window while Thread.Sleep
// is running because the UI thread is blocked.
public async Task<string> WaitSynchronously()
{
// Add a using directive for System.Threading.
Thread.Sleep(10000);
return “Finished”;
}
using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
string[] args = Environment.GetCommandLineArgs();
if (args.Length > 1)
GetPageSizeAsync(args[1]).Wait();
else
Console.WriteLine(“Enter at least one URL on the command line.”);
}
private static async Task GetPageSizeAsync(string url)
{
var client = new HttpClient();
var uri = new Uri(Uri.EscapeUriString(url));
byte[] urlContents = await client.GetByteArrayAsync(uri);
Console.WriteLine($”{url}: {urlContents.Length/2:N0} characters”);
}
}
// The following call from the command line:
// await1 http://docs.microsoft.com
// displays output like the following:
// http://docs.microsoft.com: 7,967 characters
//In a separate class:
using System;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
class Example
{
static async Task Main()
{
string[] args = Environment.GetCommandLineArgs();
if (args.Length < 2)
throw new ArgumentNullException(“No URIs specified on the command line.”);
// Don’t pass the executable file name
var uris = args.Skip(1).ToArray();
long characters = await GetPageLengthsAsync(uris);
Console.WriteLine($”{uris.Length} pages, {characters:N0} characters”);
}
private static async Task<long> GetPageLengthsAsync(string[] uris)
{
var client = new HttpClient();
long pageLengths = 0;
foreach (var uri in uris)
{
var escapedUri = new Uri(Uri.EscapeUriString(uri));
string pageContents = await client.GetStringAsync(escapedUri);
Interlocked.Add(ref pageLengths, pageContents.Length);
}
return pageLengths;
}
}
We use cookies on our website to give you the most relevant experience by remembering your preferences and repeat visits. By clicking “Accept All”, you consent to the use of ALL the cookies. However, you may visit "Cookie Settings" to provide a controlled consent.
This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary cookies are absolutely essential for the website to function properly. These cookies ensure basic functionalities and security features of the website, anonymously.
Cookie
Duration
Description
cookielawinfo-checkbox-analytics
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checkbox-functional
11 months
The cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checkbox-necessary
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-others
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-performance
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy
11 months
The cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.
Functional cookies help to perform certain functionalities like sharing the content of the website on social media platforms, collect feedbacks, and other third-party features.
Performance cookies are used to understand and analyze the key performance indexes of the website which helps in delivering a better user experience for the visitors.
Analytical cookies are used to understand how visitors interact with the website. These cookies help provide information on metrics the number of visitors, bounce rate, traffic source, etc.
Advertisement cookies are used to provide visitors with relevant ads and marketing campaigns. These cookies track visitors across websites and collect information to provide customized ads.
